falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
101072 Commits
32 Branches
369MB
Tree: 68fa294bf8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '68fa294bf8'
${ noResults }
FFmpeg/libavcodec/dpx.c

762 lines
23KB
Raw Blame History 

  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 6081:

  501.     case 6080:

  502.         avctx->pix_fmt = AV_PIX_FMT_GRAY8;

  503.         break;

  504.     case 6121:

  505.     case 6120:

  506.         avctx->pix_fmt = AV_PIX_FMT_GRAY12;

  507.         break;

  508.     case 1320:

  509.     case 2320:

  510.     case 3320:

  511.     case 4320:

  512.     case 6320:

  513.         avctx->pix_fmt = AV_PIX_FMT_GRAYF32LE;

  514.         break;

  515.     case 1321:

  516.     case 2321:

  517.     case 3321:

  518.     case 4321:

  519.     case 6321:

  520.         avctx->pix_fmt = AV_PIX_FMT_GRAYF32BE;

  521.         break;

  522.     case 50081:

  523.     case 50080:

  524.         avctx->pix_fmt = AV_PIX_FMT_RGB24;

  525.         break;

  526.     case 52081:

  527.     case 52080:

  528.         avctx->pix_fmt = AV_PIX_FMT_ABGR;

  529.         break;

  530.     case 51081:

  531.     case 51080:

  532.         avctx->pix_fmt = AV_PIX_FMT_RGBA;

  533.         break;

  534.     case 50100:

  535.     case 50101:

  536.         avctx->pix_fmt = AV_PIX_FMT_GBRP10;

  537.         break;

  538.     case 51100:

  539.     case 51101:

  540.         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;

  541.         break;

  542.     case 50120:

  543.     case 50121:

  544.         avctx->pix_fmt = AV_PIX_FMT_GBRP12;

  545.         break;

  546.     case 51120:

  547.     case 51121:

  548.         avctx->pix_fmt = AV_PIX_FMT_GBRAP12;

  549.         break;

  550.     case 6100:

  551.     case 6101:

  552.         avctx->pix_fmt = AV_PIX_FMT_GRAY10;

  553.         break;

  554.     case 6161:

  555.         avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;

  556.         break;

  557.     case 6160:

  558.         avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;

  559.         break;

  560.     case 50161:

  561.         avctx->pix_fmt = AV_PIX_FMT_RGB48BE;

  562.         break;

  563.     case 50160:

  564.         avctx->pix_fmt = AV_PIX_FMT_RGB48LE;

  565.         break;

  566.     case 51161:

  567.         avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;

  568.         break;

  569.     case 51160:

  570.         avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;

  571.         break;

  572.     case 50320:

  573.         avctx->pix_fmt = AV_PIX_FMT_GBRPF32LE;

  574.         break;

  575.     case 50321:

  576.         avctx->pix_fmt = AV_PIX_FMT_GBRPF32BE;

  577.         break;

  578.     case 51320:

  579.         avctx->pix_fmt = AV_PIX_FMT_GBRAPF32LE;

  580.         break;

  581.     case 51321:

  582.         avctx->pix_fmt = AV_PIX_FMT_GBRAPF32BE;

  583.         break;

  584.     case 100081:

  585.         avctx->pix_fmt = AV_PIX_FMT_UYVY422;

  586.         break;

  587.     case 102081:

  588.         avctx->pix_fmt = AV_PIX_FMT_YUV444P;

  589.         break;

  590.     case 103081:

  591.         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;

  592.         break;

  593.     default:

  594.         av_log(avctx, AV_LOG_ERROR, "Unsupported format %d\n",

  595.                1000 * descriptor + 10 * bits_per_color + endian);

  596.         return AVERROR_PATCHWELCOME;

  597.     }

  598. 

  599.     ff_set_sar(avctx, avctx->sample_aspect_ratio);

  600. 

  601.     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

  602.         return ret;

  603. 

  604.     av_strlcpy(creator, avpkt->data + 160, 100);

  605.     creator[100] = '\0';

  606.     av_dict_set(&p->metadata, "Creator", creator, 0);

  607. 

  608.     av_strlcpy(input_device, avpkt->data + 1556, 32);

  609.     input_device[32] = '\0';

  610.     av_dict_set(&p->metadata, "Input Device", input_device, 0);

  611. 

  612.     // Some devices do not pad 10bit samples to whole 32bit words per row

  613.     if (!memcmp(input_device, "Scanity", 7) ||

  614.         !memcmp(creator, "Lasergraphics Inc.", 18)) {

  615.         unpadded_10bit = 1;

  616.     }

  617. 

  618.     // Move pointer to offset from start of file

  619.     buf =  avpkt->data + offset;

  620. 

  621.     for (i=0; i<AV_NUM_DATA_POINTERS; i++)

  622.         ptr[i] = p->data[i];

  623. 

  624.     switch (bits_per_color) {

  625.     case 10:

  626.         for (x = 0; x < avctx->height; x++) {

  627.             uint16_t *dst[4] = {(uint16_t*)ptr[0],

  628.                                 (uint16_t*)ptr[1],

  629.                                 (uint16_t*)ptr[2],

  630.                                 (uint16_t*)ptr[3]};

  631.             int shift = elements > 1 ? packing == 1 ? 22 : 20 : packing == 1 ? 2 : 0;

  632.             for (y = 0; y < avctx->width; y++) {

  633.                 if (elements >= 3)

  634.                     *dst[2]++ = read10in32(&buf, &rgbBuffer,

  635.                                            &n_datum, endian, shift);

  636.                 if (elements == 1)

  637.                     *dst[0]++ = read10in32_gray(&buf, &rgbBuffer,

  638.                                                 &n_datum, endian, shift);

  639.                 else

  640.                     *dst[0]++ = read10in32(&buf, &rgbBuffer,

  641.                                            &n_datum, endian, shift);

  642.                 if (elements >= 2)

  643.                     *dst[1]++ = read10in32(&buf, &rgbBuffer,

  644.                                            &n_datum, endian, shift);

  645.                 if (elements == 4)

  646.                     *dst[3]++ =

  647.                     read10in32(&buf, &rgbBuffer,

  648.                                &n_datum, endian, shift);

  649.             }

  650.             if (!unpadded_10bit)

  651.                 n_datum = 0;

  652.             for (i = 0; i < elements; i++)

  653.                 ptr[i] += p->linesize[i];

  654.         }

  655.         break;

  656.     case 12:

  657.         for (x = 0; x < avctx->height; x++) {

  658.             uint16_t *dst[4] = {(uint16_t*)ptr[0],

  659.                                 (uint16_t*)ptr[1],

  660.                                 (uint16_t*)ptr[2],

  661.                                 (uint16_t*)ptr[3]};

  662.             int shift = packing == 1 ? 4 : 0;

  663.             for (y = 0; y < avctx->width; y++) {

  664.                 if (packing) {

  665.                     if (elements >= 3)

  666.                         *dst[2]++ = read16(&buf, endian) >> shift & 0xFFF;

  667.                     *dst[0]++ = read16(&buf, endian) >> shift & 0xFFF;

  668.                     if (elements >= 2)

  669.                         *dst[1]++ = read16(&buf, endian) >> shift & 0xFFF;

  670.                     if (elements == 4)

  671.                         *dst[3]++ = read16(&buf, endian) >> shift & 0xFFF;

  672.                 } else {

  673.                     if (elements >= 3)

  674.                         *dst[2]++ = read12in32(&buf, &rgbBuffer,

  675.                                                &n_datum, endian);

  676.                     *dst[0]++ = read12in32(&buf, &rgbBuffer,

  677.                                            &n_datum, endian);

  678.                     if (elements >= 2)

  679.                         *dst[1]++ = read12in32(&buf, &rgbBuffer,

  680.                                                &n_datum, endian);

  681.                     if (elements == 4)

  682.                         *dst[3]++ = read12in32(&buf, &rgbBuffer,

  683.                                                &n_datum, endian);

  684.                 }

  685.             }

  686.             n_datum = 0;

  687.             for (i = 0; i < elements; i++)

  688.                 ptr[i] += p->linesize[i];

  689.             // Jump to next aligned position

  690.             buf += need_align;

  691.         }

  692.         break;

  693.     case 32:

  694.         if (elements == 1) {

  695.             av_image_copy_plane(ptr[0], p->linesize[0],

  696.                                 buf, stride,

  697.                                 elements * avctx->width * 4, avctx->height);

  698.         } else {

  699.             for (y = 0; y < avctx->height; y++) {

  700.                 ptr[0] = p->data[0] + y * p->linesize[0];

  701.                 ptr[1] = p->data[1] + y * p->linesize[1];

  702.                 ptr[2] = p->data[2] + y * p->linesize[2];

  703.                 ptr[3] = p->data[3] + y * p->linesize[3];

  704.                 for (x = 0; x < avctx->width; x++) {

  705.                     AV_WN32(ptr[2], AV_RN32(buf));

  706.                     AV_WN32(ptr[0], AV_RN32(buf + 4));

  707.                     AV_WN32(ptr[1], AV_RN32(buf + 8));

  708.                     if (avctx->pix_fmt == AV_PIX_FMT_GBRAPF32BE ||

  709.                         avctx->pix_fmt == AV_PIX_FMT_GBRAPF32LE) {

  710.                         AV_WN32(ptr[3], AV_RN32(buf + 12));

  711.                         buf += 4;

  712.                         ptr[3] += 4;

  713.                     }

  714. 

  715.                     buf += 12;

  716.                     ptr[2] += 4;

  717.                     ptr[0] += 4;

  718.                     ptr[1] += 4;

  719.                 }

  720.             }

  721.         }

  722.         break;

  723.     case 16:

  724.         elements *= 2;

  725.     case 8:

  726.         if (   avctx->pix_fmt == AV_PIX_FMT_YUVA444P

  727.             || avctx->pix_fmt == AV_PIX_FMT_YUV444P) {

  728.             for (x = 0; x < avctx->height; x++) {

  729.                 ptr[0] = p->data[0] + x * p->linesize[0];

  730.                 ptr[1] = p->data[1] + x * p->linesize[1];

  731.                 ptr[2] = p->data[2] + x * p->linesize[2];

  732.                 ptr[3] = p->data[3] + x * p->linesize[3];

  733.                 for (y = 0; y < avctx->width; y++) {

  734.                     *ptr[1]++ = *buf++;

  735.                     *ptr[0]++ = *buf++;

  736.                     *ptr[2]++ = *buf++;

  737.                     if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P)

  738.                         *ptr[3]++ = *buf++;

  739.                 }

  740.             }

  741.         } else {

  742.         av_image_copy_plane(ptr[0], p->linesize[0],

  743.                             buf, stride,

  744.                             elements * avctx->width, avctx->height);

  745.         }

  746.         break;

  747.     }

  748. 

  749.     *got_frame = 1;

  750. 

  751.     return buf_size;

  752. }

  753. 

  754. AVCodec ff_dpx_decoder = {

  755.     .name           = "dpx",

  756.     .long_name      = NULL_IF_CONFIG_SMALL("DPX (Digital Picture Exchange) image"),

  757.     .type           = AVMEDIA_TYPE_VIDEO,

  758.     .id             = AV_CODEC_ID_DPX,

  759.     .decode         = decode_frame,

  760.     .capabilities   = AV_CODEC_CAP_DR1,

  761. };