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.
91288 Commits
32 Branches
341MB
Tree: 78298bce70
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '78298bce70'
${ noResults }
FFmpeg/libavcodec/dpx.c

471 lines
14KB
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/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 uint16_t read12in32(const uint8_t **ptr, uint32_t * lbuf,

  69.                                   int * n_datum, int is_big)

  70. {

  71.     if (*n_datum)

  72.         (*n_datum)--;

  73.     else {

  74.         *lbuf = read32(ptr, is_big);

  75.         *n_datum = 7;

  76.     }

  77. 

  78.     switch (*n_datum){

  79.     case 7: return *lbuf & 0xFFF;

  80.     case 6: return (*lbuf >> 12) & 0xFFF;

  81.     case 5: {

  82.             uint32_t c = *lbuf >> 24;

  83.             *lbuf = read32(ptr, is_big);

  84.             c |= *lbuf << 8;

  85.             return c & 0xFFF;

  86.             }

  87.     case 4: return (*lbuf >> 4) & 0xFFF;

  88.     case 3: return (*lbuf >> 16) & 0xFFF;

  89.     case 2: {

  90.             uint32_t c = *lbuf >> 28;

  91.             *lbuf = read32(ptr, is_big);

  92.             c |= *lbuf << 4;

  93.             return c & 0xFFF;

  94.             }

  95.     case 1: return (*lbuf >> 8) & 0xFFF;

  96.     default: return *lbuf >> 20;

  97.     }

  98. }

  99. 

  100. static int decode_frame(AVCodecContext *avctx,

  101.                         void *data,

  102.                         int *got_frame,

  103.                         AVPacket *avpkt)

  104. {

  105.     const uint8_t *buf = avpkt->data;

  106.     int buf_size       = avpkt->size;

  107.     AVFrame *const p = data;

  108.     uint8_t *ptr[AV_NUM_DATA_POINTERS];

  109. 

  110.     unsigned int offset;

  111.     int magic_num, endian;

  112.     int x, y, stride, i, ret;

  113.     int w, h, bits_per_color, descriptor, elements, packing;

  114.     int encoding, need_align = 0;

  115. 

  116.     unsigned int rgbBuffer = 0;

  117.     int n_datum = 0;

  118. 

  119.     if (avpkt->size <= 1634) {

  120.         av_log(avctx, AV_LOG_ERROR, "Packet too small for DPX header\n");

  121.         return AVERROR_INVALIDDATA;

  122.     }

  123. 

  124.     magic_num = AV_RB32(buf);

  125.     buf += 4;

  126. 

  127.     /* Check if the files "magic number" is "SDPX" which means it uses

  128.      * big-endian or XPDS which is for little-endian files */

  129.     if (magic_num == AV_RL32("SDPX")) {

  130.         endian = 0;

  131.     } else if (magic_num == AV_RB32("SDPX")) {

  132.         endian = 1;

  133.     } else {

  134.         av_log(avctx, AV_LOG_ERROR, "DPX marker not found\n");

  135.         return AVERROR_INVALIDDATA;

  136.     }

  137. 

  138.     offset = read32(&buf, endian);

  139.     if (avpkt->size <= offset) {

  140.         av_log(avctx, AV_LOG_ERROR, "Invalid data start offset\n");

  141.         return AVERROR_INVALIDDATA;

  142.     }

  143. 

  144.     // Check encryption

  145.     buf = avpkt->data + 660;

  146.     ret = read32(&buf, endian);

  147.     if (ret != 0xFFFFFFFF) {

  148.         avpriv_report_missing_feature(avctx, "Encryption");

  149.         av_log(avctx, AV_LOG_WARNING, "The image is encrypted and may "

  150.                "not properly decode.\n");

  151.     }

  152. 

  153.     // Need to end in 0x304 offset from start of file

  154.     buf = avpkt->data + 0x304;

  155.     w = read32(&buf, endian);

  156.     h = read32(&buf, endian);

  157. 

  158.     if ((ret = ff_set_dimensions(avctx, w, h)) < 0)

  159.         return ret;

  160. 

  161.     // Need to end in 0x320 to read the descriptor

  162.     buf += 20;

  163.     descriptor = buf[0];

  164. 

  165.     // Need to end in 0x323 to read the bits per color

  166.     buf += 3;

  167.     avctx->bits_per_raw_sample =

  168.     bits_per_color = buf[0];

  169.     buf++;

  170.     packing = read16(&buf, endian);

  171.     encoding = read16(&buf, endian);

  172. 

  173.     if (packing > 1) {

  174.         avpriv_report_missing_feature(avctx, "Packing %d", packing);

  175.         return AVERROR_PATCHWELCOME;

  176.     }

  177.     if (encoding) {

  178.         avpriv_report_missing_feature(avctx, "Encoding %d", encoding);

  179.         return AVERROR_PATCHWELCOME;

  180.     }

  181. 

  182.     buf += 820;

  183.     avctx->sample_aspect_ratio.num = read32(&buf, endian);

  184.     avctx->sample_aspect_ratio.den = read32(&buf, endian);

  185.     if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0)

  186.         av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,

  187.                    avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den,

  188.                   0x10000);

  189.     else

  190.         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };

  191. 

  192.     if (offset >= 1724 + 4) {

  193.         buf = avpkt->data + 1724;

  194.         i = read32(&buf, endian);

  195.         if(i) {

  196.             AVRational q = av_d2q(av_int2float(i), 4096);

  197.             if (q.num > 0 && q.den > 0)

  198.                 avctx->framerate = q;

  199.         }

  200.     }

  201. 

  202.     switch (descriptor) {

  203.     case 6:  // Y

  204.         elements = 1;

  205.         break;

  206.     case 52: // ABGR

  207.     case 51: // RGBA

  208.     case 103: // UYVA4444

  209.         elements = 4;

  210.         break;

  211.     case 50: // RGB

  212.     case 102: // UYV444

  213.         elements = 3;

  214.         break;

  215.     case 100: // UYVY422

  216.         elements = 2;

  217.         break;

  218.     default:

  219.         avpriv_report_missing_feature(avctx, "Descriptor %d", descriptor);

  220.         return AVERROR_PATCHWELCOME;

  221.     }

  222. 

  223.     switch (bits_per_color) {

  224.     case 8:

  225.         stride = avctx->width * elements;

  226.         break;

  227.     case 10:

  228.         if (!packing) {

  229.             av_log(avctx, AV_LOG_ERROR, "Packing to 32bit required\n");

  230.             return -1;

  231.         }

  232.         stride = (avctx->width * elements + 2) / 3 * 4;

  233.         break;

  234.     case 12:

  235.         if (!packing) {

  236.             int tested = 0;

  237.             if (descriptor == 50 && endian) { // Little endian needs tests

  238.                 tested = 1;

  239.             }

  240.             if (descriptor == 51 && endian) { // Little endian needs tests

  241.                 tested = 1;

  242.             }

  243.             if (!tested) {

  244.                 av_log(avctx, AV_LOG_ERROR, "Packing to 16bit required\n");

  245.                 return -1;

  246.             }

  247.         }

  248.         stride = avctx->width * elements;

  249.         if (packing) {

  250.             stride *= 2;

  251.         } else {

  252.             stride *= 3;

  253.             if (stride % 8) {

  254.                 stride /= 8;

  255.                 stride++;

  256.                 stride *= 8;

  257.             }

  258.             stride /= 2;

  259.         }

  260.         break;

  261.     case 16:

  262.         stride = 2 * avctx->width * elements;

  263.         break;

  264.     case 1:

  265.     case 32:

  266.     case 64:

  267.         avpriv_report_missing_feature(avctx, "Depth %d", bits_per_color);

  268.         return AVERROR_PATCHWELCOME;

  269.     default:

  270.         return AVERROR_INVALIDDATA;

  271.     }

  272. 

  273.     // Table 3c: Runs will always break at scan line boundaries. Packing

  274.     // will always break to the next 32-bit word at scan-line boundaries.

  275.     // Unfortunately, the encoder produced invalid files, so attempt

  276.     // to detect it

  277.     need_align = FFALIGN(stride, 4);

  278.     if (need_align*avctx->height + (int64_t)offset > avpkt->size) {

  279.         // Alignment seems unappliable, try without

  280.         if (stride*avctx->height + (int64_t)offset > avpkt->size) {

  281.             av_log(avctx, AV_LOG_ERROR, "Overread buffer. Invalid header?\n");

  282.             return AVERROR_INVALIDDATA;

  283.         } else {

  284.             av_log(avctx, AV_LOG_INFO, "Decoding DPX without scanline "

  285.                    "alignment.\n");

  286.             need_align = 0;

  287.         }

  288.     } else {

  289.         need_align -= stride;

  290.         stride = FFALIGN(stride, 4);

  291.     }

  292. 

  293.     switch (1000 * descriptor + 10 * bits_per_color + endian) {

  294.     case 6081:

  295.     case 6080:

  296.         avctx->pix_fmt = AV_PIX_FMT_GRAY8;

  297.         break;

  298.     case 6121:

  299.     case 6120:

  300.         avctx->pix_fmt = AV_PIX_FMT_GRAY12;

  301.         break;

  302.     case 50081:

  303.     case 50080:

  304.         avctx->pix_fmt = AV_PIX_FMT_RGB24;

  305.         break;

  306.     case 52081:

  307.     case 52080:

  308.         avctx->pix_fmt = AV_PIX_FMT_ABGR;

  309.         break;

  310.     case 51081:

  311.     case 51080:

  312.         avctx->pix_fmt = AV_PIX_FMT_RGBA;

  313.         break;

  314.     case 50100:

  315.     case 50101:

  316.         avctx->pix_fmt = AV_PIX_FMT_GBRP10;

  317.         break;

  318.     case 51100:

  319.     case 51101:

  320.         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;

  321.         break;

  322.     case 50120:

  323.     case 50121:

  324.         avctx->pix_fmt = AV_PIX_FMT_GBRP12;

  325.         break;

  326.     case 51120:

  327.     case 51121:

  328.         avctx->pix_fmt = AV_PIX_FMT_GBRAP12;

  329.         break;

  330.     case 6161:

  331.         avctx->pix_fmt = AV_PIX_FMT_GRAY16BE;

  332.         break;

  333.     case 6160:

  334.         avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;

  335.         break;

  336.     case 50161:

  337.         avctx->pix_fmt = AV_PIX_FMT_RGB48BE;

  338.         break;

  339.     case 50160:

  340.         avctx->pix_fmt = AV_PIX_FMT_RGB48LE;

  341.         break;

  342.     case 51161:

  343.         avctx->pix_fmt = AV_PIX_FMT_RGBA64BE;

  344.         break;

  345.     case 51160:

  346.         avctx->pix_fmt = AV_PIX_FMT_RGBA64LE;

  347.         break;

  348.     case 100081:

  349.         avctx->pix_fmt = AV_PIX_FMT_UYVY422;

  350.         break;

  351.     case 102081:

  352.         avctx->pix_fmt = AV_PIX_FMT_YUV444P;

  353.         break;

  354.     case 103081:

  355.         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;

  356.         break;

  357.     default:

  358.         av_log(avctx, AV_LOG_ERROR, "Unsupported format\n");

  359.         return AVERROR_PATCHWELCOME;

  360.     }

  361. 

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

  363. 

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

  365.         return ret;

  366. 

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

  368.     buf =  avpkt->data + offset;

  369. 

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

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

  372. 

  373.     switch (bits_per_color) {

  374.     case 10:

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

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

  377.                                 (uint16_t*)ptr[1],

  378.                                 (uint16_t*)ptr[2],

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

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

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

  382.                                        &n_datum, endian);

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

  384.                                        &n_datum, endian);

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

  386.                                        &n_datum, endian);

  387.                 if (elements == 4)

  388.                     *dst[3]++ =

  389.                     read10in32(&buf, &rgbBuffer,

  390.                                &n_datum, endian);

  391.             }

  392.             n_datum = 0;

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

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

  395.         }

  396.         break;

  397.     case 12:

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

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

  400.                                 (uint16_t*)ptr[1],

  401.                                 (uint16_t*)ptr[2],

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

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

  404.                 if (packing) {

  405.                 if (elements >= 3)

  406.                     *dst[2]++ = read16(&buf, endian) >> 4;

  407.                 *dst[0] = read16(&buf, endian) >> 4;

  408.                 dst[0]++;

  409.                 if (elements >= 2)

  410.                     *dst[1]++ = read16(&buf, endian) >> 4;

  411.                 if (elements == 4)

  412.                     *dst[3]++ = read16(&buf, endian) >> 4;

  413.                 } else {

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

  415.                                            &n_datum, endian);

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

  417.                                            &n_datum, endian);

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

  419.                                            &n_datum, endian);

  420.                     if (elements == 4)

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

  422.                                                &n_datum, endian);

  423.                 }

  424.             }

  425.             n_datum = 0;

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

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

  428.             // Jump to next aligned position

  429.             buf += need_align;

  430.         }

  431.         break;

  432.     case 16:

  433.         elements *= 2;

  434.     case 8:

  435.         if (   avctx->pix_fmt == AV_PIX_FMT_YUVA444P

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

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

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

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

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

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

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

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

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

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

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

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

  448.                 }

  449.             }

  450.         } else {

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

  452.                             buf, stride,

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

  454.         }

  455.         break;

  456.     }

  457. 

  458.     *got_frame = 1;

  459. 

  460.     return buf_size;

  461. }

  462. 

  463. AVCodec ff_dpx_decoder = {

  464.     .name           = "dpx",

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

  466.     .type           = AVMEDIA_TYPE_VIDEO,

  467.     .id             = AV_CODEC_ID_DPX,

  468.     .decode         = decode_frame,

  469.     .capabilities   = AV_CODEC_CAP_DR1,

  470. };