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/avstring.h"
  23 #include "libavutil/intreadwrite.h"
  24 #include "libavutil/intfloat.h"
  25 #include "libavutil/imgutils.h"
  26 #include "libavutil/timecode.h"
  27 #include "bytestream.h"
  28 #include "avcodec.h"
  29 #include "internal.h"
  30
  31 enum DPX_TRC {
  32     DPX_TRC_USER_DEFINED       = 0,
  33     DPX_TRC_PRINTING_DENSITY   = 1,
  34     DPX_TRC_LINEAR             = 2,
  35     DPX_TRC_LOGARITHMIC        = 3,
  36     DPX_TRC_UNSPECIFIED_VIDEO  = 4,
  37     DPX_TRC_SMPTE_274          = 5,
  38     DPX_TRC_ITU_R_709_4        = 6,
  39     DPX_TRC_ITU_R_601_625      = 7,
  40     DPX_TRC_ITU_R_601_525      = 8,
  41     DPX_TRC_SMPTE_170          = 9,
  42     DPX_TRC_ITU_R_624_4_PAL    = 10,
  43     DPX_TRC_Z_LINEAR           = 11,
  44     DPX_TRC_Z_HOMOGENEOUS      = 12,
  45 };
  46
  47 enum DPX_COL_SPEC {
  48     DPX_COL_SPEC_USER_DEFINED       = 0,
  49     DPX_COL_SPEC_PRINTING_DENSITY   = 1,
  50     /* 2 = N/A */
  51     /* 3 = N/A */
  52     DPX_COL_SPEC_UNSPECIFIED_VIDEO  = 4,
  53     DPX_COL_SPEC_SMPTE_274          = 5,
  54     DPX_COL_SPEC_ITU_R_709_4        = 6,
  55     DPX_COL_SPEC_ITU_R_601_625      = 7,
  56     DPX_COL_SPEC_ITU_R_601_525      = 8,
  57     DPX_COL_SPEC_SMPTE_170          = 9,
  58     DPX_COL_SPEC_ITU_R_624_4_PAL    = 10,
  59     /* 11 = N/A */
  60     /* 12 = N/A */
  61 };
  62
  63 static unsigned int read16(const uint8_t **ptr, int is_big)
  64 {
  65     unsigned int temp;
  66     if (is_big) {
  67         temp = AV_RB16(*ptr);
  68     } else {
  69         temp = AV_RL16(*ptr);
  70     }
  71     *ptr += 2;
  72     return temp;
  73 }
  74
  75 static unsigned int read32(const uint8_t **ptr, int is_big)
  76 {
  77     unsigned int temp;
  78     if (is_big) {
  79         temp = AV_RB32(*ptr);
  80     } else {
  81         temp = AV_RL32(*ptr);
  82     }
  83     *ptr += 4;
  84     return temp;
  85 }
  86
  87 static uint16_t read10in32_gray(const uint8_t **ptr, uint32_t *lbuf,
  88                                 int *n_datum, int is_big, int shift)
  89 {
  90     uint16_t temp;
  91
  92     if (*n_datum)
  93         (*n_datum)--;
  94     else {
  95         *lbuf = read32(ptr, is_big);
  96         *n_datum = 2;
  97     }
  98
  99     temp = *lbuf >> shift & 0x3FF;
 100     *lbuf = *lbuf >> 10;
 101
 102     return temp;
 103 }
 104
 105 static uint16_t read10in32(const uint8_t **ptr, uint32_t *lbuf,
 106                            int *n_datum, int is_big, int shift)
 107 {
 108     if (*n_datum)
 109         (*n_datum)--;
 110     else {
 111         *lbuf = read32(ptr, is_big);
 112         *n_datum = 2;
 113     }
 114
 115     *lbuf = *lbuf << 10 | *lbuf >> shift & 0x3FFFFF;
 116
 117     return *lbuf & 0x3FF;
 118 }
 119
 120 static uint16_t read12in32(const uint8_t **ptr, uint32_t *lbuf,
 121                            int *n_datum, int is_big)
 122 {
 123     if (*n_datum)
 124         (*n_datum)--;
 125     else {
 126         *lbuf = read32(ptr, is_big);
 127         *n_datum = 7;
 128     }
 129
 130     switch (*n_datum){
 131     case 7: return *lbuf & 0xFFF;
 132     case 6: return (*lbuf >> 12) & 0xFFF;
 133     case 5: {
 134             uint32_t c = *lbuf >> 24;
 135             *lbuf = read32(ptr, is_big);
 136             c |= *lbuf << 8;
 137             return c & 0xFFF;
 138             }
 139     case 4: return (*lbuf >> 4) & 0xFFF;
 140     case 3: return (*lbuf >> 16) & 0xFFF;
 141     case 2: {
 142             uint32_t c = *lbuf >> 28;
 143             *lbuf = read32(ptr, is_big);
 144             c |= *lbuf << 4;
 145             return c & 0xFFF;
 146             }
 147     case 1: return (*lbuf >> 8) & 0xFFF;
 148     default: return *lbuf >> 20;
 149     }
 150 }
 151
 152 static int decode_frame(AVCodecContext *avctx,
 153                         void *data,
 154                         int *got_frame,
 155                         AVPacket *avpkt)
 156 {
 157     const uint8_t *buf = avpkt->data;
 158     int buf_size       = avpkt->size;
 159     AVFrame *const p = data;
 160     uint8_t *ptr[AV_NUM_DATA_POINTERS];
 161     uint32_t header_version, version = 0;
 162     char creator[101] = { 0 };
 163     char input_device[33] = { 0 };
 164
 165     unsigned int offset;
 166     int magic_num, endian;
 167     int x, y, stride, i, j, ret;
 168     int w, h, bits_per_color, descriptor, elements, packing;
 169     int yuv, color_trc, color_spec;
 170     int encoding, need_align = 0, unpadded_10bit = 0;
 171
 172     unsigned int rgbBuffer = 0;
 173     int n_datum = 0;
 174
 175     if (avpkt->size <= 1634) {
 176         av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");
 177         return AVERROR_INVALIDDATA;
 178     }
 179
 180     magic_num = AV_RB32(buf);
 181     buf += 4;
 182
 183     /* Check if the files "magic number" is "SDPX" which means it uses
 184      * big-endian or XPDS which is for little-endian files */
 185     if (magic_num == AV_RL32("SDPX")) {
 186         endian = 0;
 187     } else if (magic_num == AV_RB32("SDPX")) {
 188         endian = 1;
 189     } else {
 190         av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");
 191         return AVERROR_INVALIDDATA;
 192     }
 193
 194     offset = read32(&buf, endian);
 195     if (avpkt->size <= offset) {
 196         av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");
 197         return AVERROR_INVALIDDATA;
 198     }
 199
 200     header_version = read32(&buf, 0);
 201     if (header_version == MKTAG('V','1','.','0'))
 202         version = 1;
 203     if (header_version == MKTAG('V','2','.','0'))
 204         version = 2;
 205     if (!version)
 206         av_log(avctx, AV_LOG_WARNING, "Unknown header format version %s.\n",
 207                av_fourcc2str(header_version));
 208
 209     // Check encryption
 210     buf = avpkt->data + 660;
 211     ret = read32(&buf, endian);
 212     if (ret != 0xFFFFFFFF) {
 213         avpriv_report_missing_feature(avctx, "Encryption");
 214         av_log(avctx, AV_LOG_WARNING, "The image is encrypted and may "
 215                "not properly decode.\n");
 216     }
 217
 218     // Need to end in 0x304 offset from start of file
 219     buf = avpkt->data + 0x304;
 220     w = read32(&buf, endian);
 221     h = read32(&buf, endian);
 222
 223     if ((ret = ff_set_dimensions(avctx, w, h)) < 0)
 224         return ret;
 225
 226     // Need to end in 0x320 to read the descriptor
 227     buf += 20;
 228     descriptor = buf[0];
 229     color_trc = buf[1];
 230     color_spec = buf[2];
 231
 232     // Need to end in 0x323 to read the bits per color
 233     buf += 3;
 234     avctx->bits_per_raw_sample =
 235     bits_per_color = buf[0];
 236     buf++;
 237     packing = read16(&buf, endian);
 238     encoding = read16(&buf, endian);
 239
 240     if (encoding) {
 241         avpriv_report_missing_feature(avctx, "Encoding %d", encoding);
 242         return AVERROR_PATCHWELCOME;
 243     }
 244
 245     buf += 820;
 246     avctx->sample_aspect_ratio.num = read32(&buf, endian);
 247     avctx->sample_aspect_ratio.den = read32(&buf, endian);
 248     if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)
 249         av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 250                    avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den,
 251                   0x10000);
 252     else
 253         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
 254
 255     /* preferred frame rate from Motion-picture film header */
 256     if (offset >= 1724 + 4) {
 257         buf = avpkt->data + 1724;
 258         i = read32(&buf, endian);
 259         if(i && i != 0xFFFFFFFF) {
 260             AVRational q = av_d2q(av_int2float(i), 4096);
 261             if (q.num > 0 && q.den > 0)
 262                 avctx->framerate = q;
 263         }
 264     }
 265
 266     /* alternative frame rate from television header */
 267     if (offset >= 1940 + 4 &&
 268         !(avctx->framerate.num && avctx->framerate.den)) {
 269         buf = avpkt->data + 1940;
 270         i = read32(&buf, endian);
 271         if(i && i != 0xFFFFFFFF) {
 272             AVRational q = av_d2q(av_int2float(i), 4096);
 273             if (q.num > 0 && q.den > 0)
 274                 avctx->framerate = q;
 275         }
 276     }
 277
 278     /* SMPTE TC from television header */
 279     if (offset >= 1920 + 4) {
 280         uint32_t tc;
 281         uint32_t *tc_sd;
 282         char tcbuf[AV_TIMECODE_STR_SIZE];
 283
 284         buf = avpkt->data + 1920;
 285         // read32 to native endian, av_bswap32 to opposite of native for
 286         // compatibility with av_timecode_make_smpte_tc_string2 etc
 287         tc = av_bswap32(read32(&buf, endian));
 288
 289         if (i != 0xFFFFFFFF) {
 290             AVFrameSideData *tcside =
 291                 av_frame_new_side_data(p, AV_FRAME_DATA_S12M_TIMECODE,
 292                                        sizeof(uint32_t) * 4);
 293             if (!tcside)
 294                 return AVERROR(ENOMEM);
 295
 296             tc_sd = (uint32_t*)tcside->data;
 297             tc_sd[0] = 1;
 298             tc_sd[1] = tc;
 299
 300             av_timecode_make_smpte_tc_string2(tcbuf, avctx->framerate,
 301                                               tc_sd[1], 0, 0);
 302             av_dict_set(&p->metadata, "timecode", tcbuf, 0);
 303         }
 304     }
 305
 306     /* color range from television header */
 307     if (offset >= 1964 + 4) {
 308         buf = avpkt->data + 1952;
 309         i = read32(&buf, endian);
 310
 311         buf = avpkt->data + 1964;
 312         j = read32(&buf, endian);
 313
 314         if (i != 0xFFFFFFFF && j != 0xFFFFFFFF) {
 315             float minCV, maxCV;
 316             minCV = av_int2float(i);
 317             maxCV = av_int2float(j);
 318             if (bits_per_color >= 1 &&
 319                 minCV == 0.0f && maxCV == ((1<<bits_per_color) - 1)) {
 320                 avctx->color_range = AVCOL_RANGE_JPEG;
 321             } else if (bits_per_color >= 8 &&
 322                        minCV == (1  <<(bits_per_color - 4)) &&
 323                        maxCV == (235<<(bits_per_color - 8))) {
 324                 avctx->color_range = AVCOL_RANGE_MPEG;
 325             }
 326         }
 327     }
 328
 329     switch (descriptor) {
 330     case 1:  // R
 331     case 2:  // G
 332     case 3:  // B
 333     case 4:  // A
 334     case 6:  // Y
 335         elements = 1;
 336         yuv = 1;
 337         break;
 338     case 50: // RGB
 339         elements = 3;
 340         yuv = 0;
 341         break;
 342     case 52: // ABGR
 343     case 51: // RGBA
 344         elements = 4;
 345         yuv = 0;
 346         break;
 347     case 100: // UYVY422
 348         elements = 2;
 349         yuv = 1;
 350         break;
 351     case 102: // UYV444
 352         elements = 3;
 353         yuv = 1;
 354         break;
 355     case 103: // UYVA4444
 356         elements = 4;
 357         yuv = 1;
 358         break;
 359     default:
 360         avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);
 361         return AVERROR_PATCHWELCOME;
 362     }
 363
 364     switch (bits_per_color) {
 365     case 8:
 366         stride = avctx->width * elements;
 367         break;
 368     case 10:
 369         if (!packing) {
 370             av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");
 371             return -1;
 372         }
 373         stride = (avctx->width * elements + 2) / 3 * 4;
 374         break;
 375     case 12:
 376         stride = avctx->width * elements;
 377         if (packing) {
 378             stride *= 2;
 379         } else {
 380             stride *= 3;
 381             if (stride % 8) {
 382                 stride /= 8;
 383                 stride++;
 384                 stride *= 8;
 385             }
 386             stride /= 2;
 387         }
 388         break;
 389     case 16:
 390         stride = 2 * avctx->width * elements;
 391         break;
 392     case 32:
 393         stride = 4 * avctx->width * elements;
 394         break;
 395     case 1:
 396     case 64:
 397         avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);
 398         return AVERROR_PATCHWELCOME;
 399     default:
 400         return AVERROR_INVALIDDATA;
 401     }
 402
 403     switch (color_trc) {
 404     case DPX_TRC_LINEAR:
 405         avctx->color_trc = AVCOL_TRC_LINEAR;
 406         break;
 407     case DPX_TRC_SMPTE_274:
 408     case DPX_TRC_ITU_R_709_4:
 409         avctx->color_trc = AVCOL_TRC_BT709;
 410         break;
 411     case DPX_TRC_ITU_R_601_625:
 412     case DPX_TRC_ITU_R_601_525:
 413     case DPX_TRC_SMPTE_170:
 414         avctx->color_trc = AVCOL_TRC_SMPTE170M;
 415         break;
 416     case DPX_TRC_ITU_R_624_4_PAL:
 417         avctx->color_trc = AVCOL_TRC_GAMMA28;
 418         break;
 419     case DPX_TRC_USER_DEFINED:
 420     case DPX_TRC_UNSPECIFIED_VIDEO:
 421         /* Nothing to do */
 422         break;
 423     default:
 424         av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX transfer characteristic "
 425             "%d to color_trc.\n", color_trc);
 426         break;
 427     }
 428
 429     switch (color_spec) {
 430     case DPX_COL_SPEC_SMPTE_274:
 431     case DPX_COL_SPEC_ITU_R_709_4:
 432         avctx->color_primaries = AVCOL_PRI_BT709;
 433         break;
 434     case DPX_COL_SPEC_ITU_R_601_625:
 435     case DPX_COL_SPEC_ITU_R_624_4_PAL:
 436         avctx->color_primaries = AVCOL_PRI_BT470BG;
 437         break;
 438     case DPX_COL_SPEC_ITU_R_601_525:
 439     case DPX_COL_SPEC_SMPTE_170:
 440         avctx->color_primaries = AVCOL_PRI_SMPTE170M;
 441         break;
 442     case DPX_COL_SPEC_USER_DEFINED:
 443     case DPX_COL_SPEC_UNSPECIFIED_VIDEO:
 444         /* Nothing to do */
 445         break;
 446     default:
 447         av_log(avctx, AV_LOG_VERBOSE, "Cannot map DPX color specification "
 448             "%d to color_primaries.\n", color_spec);
 449         break;
 450     }
 451
 452     if (yuv) {
 453         switch (color_spec) {
 454         case DPX_COL_SPEC_SMPTE_274:
 455         case DPX_COL_SPEC_ITU_R_709_4:
 456             avctx->colorspace = AVCOL_SPC_BT709;
 457             break;
 458         case DPX_COL_SPEC_ITU_R_601_625:
 459         case DPX_COL_SPEC_ITU_R_624_4_PAL:
 460             avctx->colorspace = AVCOL_SPC_BT470BG;
 461             break;
 462         case DPX_COL_SPEC_ITU_R_601_525:
 463         case DPX_COL_SPEC_SMPTE_170:
 464             avctx->colorspace = AVCOL_SPC_SMPTE170M;
 465             break;
 466         case DPX_COL_SPEC_USER_DEFINED:
 467         case DPX_COL_SPEC_UNSPECIFIED_VIDEO:
 468             /* Nothing to do */
 469             break;
 470         default:
 471             av_log(avctx, AV_LOG_INFO, "Cannot map DPX color specification "
 472                 "%d to colorspace.\n", color_spec);
 473             break;
 474         }
 475     } else {
 476         avctx->colorspace = AVCOL_SPC_RGB;
 477     }
 478
 479     // Table 3c: Runs will always break at scan line boundaries. Packing
 480     // will always break to the next 32-bit word at scan-line boundaries.
 481     // Unfortunately, the encoder produced invalid files, so attempt
 482     // to detect it
 483     need_align = FFALIGN(stride, 4);
 484     if (need_align*avctx->height + (int64_t)offset > avpkt->size) {
 485         // Alignment seems unappliable, try without
 486         if (stride*avctx->height + (int64_t)offset > avpkt->size) {
 487             av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");
 488             return AVERROR_INVALIDDATA;
 489         } else {
 490             av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "
 491                    "alignment.\n");
 492             need_align = 0;
 493         }
 494     } else {
 495         need_align -= stride;
 496         stride = FFALIGN(stride, 4);
 497     }
 498
 499     switch (1000 * descriptor + 10 * bits_per_color + endian) {
 500     case 1081:
 501     case 1080:
 502     case 2081:
 503     case 2080:
 504     case 3081:
 505     case 3080:
 506     case 4081:
 507     case 4080:
 508     case 6081:
 509     case 6080:
 510         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 511         break;
 512     case 6121:
 513     case 6120:
 514         avctx->pix_fmt = AV_PIX_FMT_GRAY12;
 515         break;
 516     case 1320:
 517     case 2320:
 518     case 3320:
 519     case 4320:
 520     case 6320:
 521         avctx->pix_fmt = AV_PIX_FMT_GRAYF32LE;
 522         break;
 523     case 1321:
 524     case 2321:
 525     case 3321:
 526     case 4321:
 527     case 6321:
 528         avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;
 529         break;
 530     case 50081:
 531     case 50080:
 532         avctx->pix_fmt = AV_PIX_FMT_RGB24;
 533         break;
 534     case 52081:
 535     case 52080:
 536         avctx->pix_fmt = AV_PIX_FMT_ABGR;
 537         break;
 538     case 51081:
 539     case 51080:
 540         avctx->pix_fmt = AV_PIX_FMT_RGBA;
 541         break;
 542     case 50100:
 543     case 50101:
 544         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 545         break;
 546     case 51100:
 547     case 51101:
 548         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
 549         break;
 550     case 50120:
 551     case 50121:
 552         avctx->pix_fmt = AV_PIX_FMT_GBRP12;
 553         break;
 554     case 51120:
 555     case 51121:
 556         avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
 557         break;
 558     case 6100:
 559     case 6101:
 560         avctx->pix_fmt = AV_PIX_FMT_GRAY10;
 561         break;
 562     case 6161:
 563         avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;
 564         break;
 565     case 6160:
 566         avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
 567         break;
 568     case 50161:
 569         avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
 570         break;
 571     case 50160:
 572         avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
 573         break;
 574     case 51161:
 575         avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;
 576         break;
 577     case 51160:
 578         avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;
 579         break;
 580     case 50320:
 581         avctx->pix_fmt = AV_PIX_FMT_GBRPF32LE;
 582         break;
 583     case 50321:
 584         avctx->pix_fmt = AV_PIX_FMT_GBRPF32BE;
 585         break;
 586     case 51320:
 587         avctx->pix_fmt = AV_PIX_FMT_GBRAPF32LE;
 588         break;
 589     case 51321:
 590         avctx->pix_fmt = AV_PIX_FMT_GBRAPF32BE;
 591         break;
 592     case 100081:
 593         avctx->pix_fmt = AV_PIX_FMT_UYVY422;
 594         break;
 595     case 102081:
 596         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 597         break;
 598     case 103081:
 599         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 600         break;
 601     default:
 602         av_log(avctx, AV_LOG_ERROR, "Unsupported format %d\n",
 603                1000 * descriptor + 10 * bits_per_color + endian);
 604         return AVERROR_PATCHWELCOME;
 605     }
 606
 607     ff_set_sar(avctx, avctx->sample_aspect_ratio);
 608
 609     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
 610         return ret;
 611
 612     av_strlcpy(creator, avpkt->data + 160, 100);
 613     creator[100] = '\0';
 614     av_dict_set(&p->metadata, "Creator", creator, 0);
 615
 616     av_strlcpy(input_device, avpkt->data + 1556, 32);
 617     input_device[32] = '\0';
 618     av_dict_set(&p->metadata, "Input Device", input_device, 0);
 619
 620     // Some devices do not pad 10bit samples to whole 32bit words per row
 621     if (!memcmp(input_device, "Scanity", 7) ||
 622         !memcmp(creator, "Lasergraphics Inc.", 18)) {
 623         unpadded_10bit = 1;
 624     }
 625
 626     // Move pointer to offset from start of file
 627     buf =  avpkt->data + offset;
 628
 629     for (i=0; i<AV_NUM_DATA_POINTERS; i++)
 630         ptr[i] = p->data[i];
 631
 632     switch (bits_per_color) {
 633     case 10:
 634         for (x = 0; x < avctx->height; x++) {
 635             uint16_t *dst[4] = {(uint16_t*)ptr[0],
 636                                 (uint16_t*)ptr[1],
 637                                 (uint16_t*)ptr[2],
 638                                 (uint16_t*)ptr[3]};
 639             int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;
 640             for (y = 0; y < avctx->width; y++) {
 641                 if (elements >= 3)
 642                     *dst[2]++ = read10in32(&buf, &rgbBuffer,
 643                                            &n_datum, endian, shift);
 644                 if (elements == 1)
 645                     *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,
 646                                                 &n_datum, endian, shift);
 647                 else
 648                     *dst[0]++ = read10in32(&buf, &rgbBuffer,
 649                                            &n_datum, endian, shift);
 650                 if (elements >= 2)
 651                     *dst[1]++ = read10in32(&buf, &rgbBuffer,
 652                                            &n_datum, endian, shift);
 653                 if (elements == 4)
 654                     *dst[3]++ =
 655                     read10in32(&buf, &rgbBuffer,
 656                                &n_datum, endian, shift);
 657             }
 658             if (!unpadded_10bit)
 659                 n_datum = 0;
 660             for (i = 0; i < elements; i++)
 661                 ptr[i] += p->linesize[i];
 662         }
 663         break;
 664     case 12:
 665         for (x = 0; x < avctx->height; x++) {
 666             uint16_t *dst[4] = {(uint16_t*)ptr[0],
 667                                 (uint16_t*)ptr[1],
 668                                 (uint16_t*)ptr[2],
 669                                 (uint16_t*)ptr[3]};
 670             int shift = packing == 1 ? 4 : 0;
 671             for (y = 0; y < avctx->width; y++) {
 672                 if (packing) {
 673                     if (elements >= 3)
 674                         *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;
 675                     *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;
 676                     if (elements >= 2)
 677                         *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;
 678                     if (elements == 4)
 679                         *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;
 680                 } else {
 681                     if (elements >= 3)
 682                         *dst[2]++ = read12in32(&buf, &rgbBuffer,
 683                                                &n_datum, endian);
 684                     *dst[0]++ = read12in32(&buf, &rgbBuffer,
 685                                            &n_datum, endian);
 686                     if (elements >= 2)
 687                         *dst[1]++ = read12in32(&buf, &rgbBuffer,
 688                                                &n_datum, endian);
 689                     if (elements == 4)
 690                         *dst[3]++ = read12in32(&buf, &rgbBuffer,
 691                                                &n_datum, endian);
 692                 }
 693             }
 694             n_datum = 0;
 695             for (i = 0; i < elements; i++)
 696                 ptr[i] += p->linesize[i];
 697             // Jump to next aligned position
 698             buf += need_align;
 699         }
 700         break;
 701     case 32:
 702         if (elements == 1) {
 703             av_image_copy_plane(ptr[0], p->linesize[0],
 704                                 buf, stride,
 705                                 elements * avctx->width * 4, avctx->height);
 706         } else {
 707             for (y = 0; y < avctx->height; y++) {
 708                 ptr[0] = p->data[0] + y * p->linesize[0];
 709                 ptr[1] = p->data[1] + y * p->linesize[1];
 710                 ptr[2] = p->data[2] + y * p->linesize[2];
 711                 ptr[3] = p->data[3] + y * p->linesize[3];
 712                 for (x = 0; x < avctx->width; x++) {
 713                     AV_WN32(ptr[2], AV_RN32(buf));
 714                     AV_WN32(ptr[0], AV_RN32(buf + 4));
 715                     AV_WN32(ptr[1], AV_RN32(buf + 8));
 716                     if (avctx->pix_fmt == AV_PIX_FMT_GBRAPF32BE ||
 717                         avctx->pix_fmt == AV_PIX_FMT_GBRAPF32LE) {
 718                         AV_WN32(ptr[3], AV_RN32(buf + 12));
 719                         buf += 4;
 720                         ptr[3] += 4;
 721                     }
 722
 723                     buf += 12;
 724                     ptr[2] += 4;
 725                     ptr[0] += 4;
 726                     ptr[1] += 4;
 727                 }
 728             }
 729         }
 730         break;
 731     case 16:
 732         elements *= 2;
 733     case 8:
 734         if (   avctx->pix_fmt == AV_PIX_FMT_YUVA444P
 735             || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
 736             for (x = 0; x < avctx->height; x++) {
 737                 ptr[0] = p->data[0] + x * p->linesize[0];
 738                 ptr[1] = p->data[1] + x * p->linesize[1];
 739                 ptr[2] = p->data[2] + x * p->linesize[2];
 740                 ptr[3] = p->data[3] + x * p->linesize[3];
 741                 for (y = 0; y < avctx->width; y++) {
 742                     *ptr[1]++ = *buf++;
 743                     *ptr[0]++ = *buf++;
 744                     *ptr[2]++ = *buf++;
 745                     if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)
 746                         *ptr[3]++ = *buf++;
 747                 }
 748             }
 749         } else {
 750         av_image_copy_plane(ptr[0], p->linesize[0],
 751                             buf, stride,
 752                             elements * avctx->width, avctx->height);
 753         }
 754         break;
 755     }
 756
 757     *got_frame = 1;
 758
 759     return buf_size;
 760 }
 761
 762 AVCodec ff_dpx_decoder = {
 763     .name           = "dpx",
 764     .long_name      = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),
 765     .type           = AVMEDIA_TYPE_VIDEO,
 766     .id             = AV_CODEC_ID_DPX,
 767     .decode         = decode_frame,
 768     .capabilities   = AV_CODEC_CAP_DR1,
 769 };