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.
78583 Commits
32 Branches
359MB
Tree: 5bf11223dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5bf11223dd'
${ noResults }
FFmpeg/libavcodec/cfhd.c

767 lines
30KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2015-2016 Kieran Kunhya <kieran@kunhya.com>

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. /**

  22.  * @file

  23.  * CFHD Video Decoder

  24.  */

  25. 

  26. #include "libavutil/buffer.h"

  27. #include "libavutil/common.h"

  28. #include "libavutil/intreadwrite.h"

  29. #include "libavutil/imgutils.h"

  30. #include "libavutil/opt.h"

  31. 

  32. #include "avcodec.h"

  33. #include "internal.h"

  34. #include "bytestream.h"

  35. #include "thread.h"

  36. #include "cfhd.h"

  37. 

  38. #define SUBBAND_COUNT 10

  39. 

  40. static av_cold int cfhd_decode_init(AVCodecContext *avctx)

  41. {

  42.     CFHDContext *s = avctx->priv_data;

  43. 

  44.     avctx->bits_per_raw_sample = 10;

  45.     s->avctx                   = avctx;

  46.     avctx->width               = 0;

  47.     avctx->height              = 0;

  48. 

  49.     return ff_cfhd_init_vlcs(s);

  50. }

  51. 

  52. static void init_plane_defaults(CFHDContext *s)

  53. {

  54.     s->subband_num        = 0;

  55.     s->level              = 0;

  56.     s->subband_num_actual = 0;

  57. }

  58. 

  59. static void init_frame_defaults(CFHDContext *s)

  60. {

  61.     s->coded_width       = 0;

  62.     s->coded_height      = 0;

  63.     s->bpc               = 10;

  64.     s->channel_cnt       = 4;

  65.     s->subband_cnt       = 10;

  66.     s->channel_num       = 0;

  67.     s->lowpass_precision = 16;

  68.     s->quantisation      = 1;

  69.     s->wavelet_depth     = 3;

  70.     s->pshift            = 1;

  71.     s->codebook          = 0;

  72.     init_plane_defaults(s);

  73. }

  74. 

  75. /* TODO: merge with VLC tables or use LUT */

  76. static inline int dequant_and_decompand(int level, int quantisation)

  77. {

  78.     int64_t abslevel = abs(level);

  79.     return (abslevel + ((768 * abslevel * abslevel * abslevel) / (255 * 255 * 255))) * FFSIGN(level) * quantisation;

  80. }

  81. 

  82. static inline void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride,

  83.                           int16_t *high, ptrdiff_t high_stride, int len, uint8_t clip)

  84. {

  85.     int16_t tmp;

  86. 

  87.     int i;

  88.     for (i = 0; i < len; i++) {

  89.         if (i == 0) {

  90.             tmp = (11*low[0*low_stride] - 4*low[1*low_stride] + low[2*low_stride] + 4) >> 3;

  91.             output[(2*i+0)*out_stride] = (tmp + high[0*high_stride]) >> 1;

  92.             if (clip)

  93.                 output[(2*i+0)*out_stride] = av_clip_uintp2_c(output[(2*i+0)*out_stride], clip);

  94. 

  95.             tmp = ( 5*low[0*low_stride] + 4*low[1*low_stride] - low[2*low_stride] + 4) >> 3;

  96.             output[(2*i+1)*out_stride] = (tmp - high[0*high_stride]) >> 1;

  97.             if (clip)

  98.                 output[(2*i+1)*out_stride] = av_clip_uintp2_c(output[(2*i+1)*out_stride], clip);

  99.         } else if (i == len-1) {

  100.             tmp = ( 5*low[i*low_stride] + 4*low[(i-1)*low_stride] - low[(i-2)*low_stride] + 4) >> 3;

  101.             output[(2*i+0)*out_stride] = (tmp + high[i*high_stride]) >> 1;

  102.             if (clip)

  103.                 output[(2*i+0)*out_stride] = av_clip_uintp2_c(output[(2*i+0)*out_stride], clip);

  104. 

  105.             tmp = (11*low[i*low_stride] - 4*low[(i-1)*low_stride] + low[(i-2)*low_stride] + 4) >> 3;

  106.             output[(2*i+1)*out_stride] = (tmp - high[i*high_stride]) >> 1;

  107.             if (clip)

  108.                 output[(2*i+1)*out_stride] = av_clip_uintp2_c(output[(2*i+1)*out_stride], clip);

  109.         } else {

  110.             tmp = (low[(i-1)*low_stride] - low[(i+1)*low_stride] + 4) >> 3;

  111.             output[(2*i+0)*out_stride] = (tmp + low[i*low_stride] + high[i*high_stride]) >> 1;

  112.             if (clip)

  113.                 output[(2*i+0)*out_stride] = av_clip_uintp2_c(output[(2*i+0)*out_stride], clip);

  114. 

  115.             tmp = (low[(i+1)*low_stride] - low[(i-1)*low_stride] + 4) >> 3;

  116.             output[(2*i+1)*out_stride] = (tmp + low[i*low_stride] - high[i*high_stride]) >> 1;

  117.             if (clip)

  118.                 output[(2*i+1)*out_stride] = av_clip_uintp2_c(output[(2*i+1)*out_stride], clip);

  119.         }

  120.     }

  121. }

  122. 

  123. static void horiz_filter(int16_t *output, int16_t *low, int16_t *high, int width)

  124. {

  125.     filter(output, 1, low, 1, high, 1, width, 0);

  126. }

  127. 

  128. static void horiz_filter_clip(int16_t *output, int16_t *low, int16_t *high, int width, uint8_t clip)

  129. {

  130.     filter(output, 1, low, 1, high, 1, width, clip);

  131. }

  132. 

  133. static void vert_filter(int16_t *output, int out_stride, int16_t *low, int low_stride,

  134.                         int16_t *high, int high_stride, int len)

  135. {

  136.     filter(output, out_stride, low, low_stride, high, high_stride, len, 0);

  137. }

  138. 

  139. static void free_buffers(AVCodecContext *avctx)

  140. {

  141.     CFHDContext *s = avctx->priv_data;

  142.     int i;

  143. 

  144.     for (i = 0; i < 3; i++) {

  145.         av_freep(&s->plane[i].idwt_buf);

  146.         av_freep(&s->plane[i].idwt_tmp);

  147.     }

  148.     s->a_height = 0;

  149.     s->a_width  = 0;

  150. }

  151. 

  152. static int alloc_buffers(AVCodecContext *avctx)

  153. {

  154.     CFHDContext *s = avctx->priv_data;

  155.     int i, j, k, ret;

  156. 

  157.     if ((ret = ff_set_dimensions(avctx, s->coded_width, s->coded_height)) < 0)

  158.         return ret;

  159. 

  160.     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);

  161. 

  162.     for (i = 0; i < 3; i++) {

  163.         int width = i ? avctx->width >> s->chroma_x_shift : avctx->width;

  164.         int height = i ? avctx->height >> s->chroma_y_shift : avctx->height;

  165.         int stride = FFALIGN(width / 8, 8) * 8;

  166.         int w8, h8, w4, h4, w2, h2;

  167.         height = FFALIGN(height / 8, 2) * 8;

  168.         s->plane[i].width = width;

  169.         s->plane[i].height = height;

  170.         s->plane[i].stride = stride;

  171. 

  172.         w8 = FFALIGN(s->plane[i].width / 8, 8);

  173.         h8 = FFALIGN(s->plane[i].height / 8, 2);

  174.         w4 = w8 * 2;

  175.         h4 = h8 * 2;

  176.         w2 = w4 * 2;

  177.         h2 = h4 * 2;

  178. 

  179.         s->plane[i].idwt_buf = av_malloc_array(height * stride, sizeof(*s->plane[i].idwt_buf));

  180.         s->plane[i].idwt_tmp = av_malloc_array(height * stride, sizeof(*s->plane[i].idwt_tmp));

  181.         if (!s->plane[i].idwt_buf || !s->plane[i].idwt_tmp) {

  182.             return AVERROR(ENOMEM);

  183.         }

  184. 

  185.         s->plane[i].subband[0] = s->plane[i].idwt_buf;

  186.         s->plane[i].subband[1] = s->plane[i].idwt_buf + 2 * w8 * h8;

  187.         s->plane[i].subband[2] = s->plane[i].idwt_buf + 1 * w8 * h8;

  188.         s->plane[i].subband[3] = s->plane[i].idwt_buf + 3 * w8 * h8;

  189.         s->plane[i].subband[4] = s->plane[i].idwt_buf + 2 * w4 * h4;

  190.         s->plane[i].subband[5] = s->plane[i].idwt_buf + 1 * w4 * h4;

  191.         s->plane[i].subband[6] = s->plane[i].idwt_buf + 3 * w4 * h4;

  192.         s->plane[i].subband[7] = s->plane[i].idwt_buf + 2 * w2 * h2;

  193.         s->plane[i].subband[8] = s->plane[i].idwt_buf + 1 * w2 * h2;

  194.         s->plane[i].subband[9] = s->plane[i].idwt_buf + 3 * w2 * h2;

  195. 

  196.         for (j = 0; j < DWT_LEVELS; j++) {

  197.             for(k = 0; k < 4; k++) {

  198.                 s->plane[i].band[j][k].a_width  = w8 << j;

  199.                 s->plane[i].band[j][k].a_height = h8 << j;

  200.             }

  201.         }

  202. 

  203.         /* ll2 and ll1 commented out because they are done in-place */

  204.         s->plane[i].l_h[0] = s->plane[i].idwt_tmp;

  205.         s->plane[i].l_h[1] = s->plane[i].idwt_tmp + 2 * w8 * h8;

  206.         //s->plane[i].l_h[2] = ll2;

  207.         s->plane[i].l_h[3] = s->plane[i].idwt_tmp;

  208.         s->plane[i].l_h[4] = s->plane[i].idwt_tmp + 2 * w4 * h4;

  209.         //s->plane[i].l_h[5] = ll1;

  210.         s->plane[i].l_h[6] = s->plane[i].idwt_tmp;

  211.         s->plane[i].l_h[7] = s->plane[i].idwt_tmp + 2 * w2 * h2;

  212.     }

  213. 

  214.     s->a_height = s->coded_height;

  215.     s->a_width  = s->coded_width;

  216. 

  217.     return 0;

  218. }

  219. 

  220. static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,

  221.                        AVPacket *avpkt)

  222. {

  223.     CFHDContext *s = avctx->priv_data;

  224.     GetByteContext gb;

  225.     ThreadFrame frame = { .f = data };

  226.     AVFrame *pic = data;

  227.     int ret = 0, i, j, plane, got_buffer = 0;

  228.     int16_t *coeff_data;

  229. 

  230.     avctx->pix_fmt = AV_PIX_FMT_YUV422P10;

  231.     init_frame_defaults(s);

  232. 

  233.     bytestream2_init(&gb, avpkt->data, avpkt->size);

  234. 

  235.     while (bytestream2_get_bytes_left(&gb) > 4) {

  236.         /* Bit weird but implement the tag parsing as the spec says */

  237.         uint16_t tagu   = bytestream2_get_be16(&gb);

  238.         int16_t tag     = (int16_t)tagu;

  239.         int8_t tag8     = (int8_t)(tagu >> 8);

  240.         uint16_t abstag = abs(tag);

  241.         int8_t abs_tag8 = abs(tag8);

  242.         uint16_t data   = bytestream2_get_be16(&gb);

  243.         if (abs_tag8 >= 0x60 && abs_tag8 <= 0x6f) {

  244.             av_log(avctx, AV_LOG_DEBUG, "large len %x\n", ((tagu & 0xff) << 16) | data);

  245.         } else if (tag == 20) {

  246.             av_log(avctx, AV_LOG_DEBUG, "Width %"PRIu16"\n", data);

  247.             s->coded_width = data;

  248.         } else if (tag == 21) {

  249.             av_log(avctx, AV_LOG_DEBUG, "Height %"PRIu16"\n", data);

  250.             s->coded_height = data;

  251.         } else if (tag == 101) {

  252.             av_log(avctx, AV_LOG_DEBUG, "Bits per component: %"PRIu16"\n", data);

  253.             s->bpc = data;

  254.         } else if (tag == 12) {

  255.             av_log(avctx, AV_LOG_DEBUG, "Channel Count: %"PRIu16"\n", data);

  256.             s->channel_cnt = data;

  257.             if (data != 3) {

  258.                 av_log(avctx, AV_LOG_ERROR, "Channel Count of %"PRIu16" is unsupported\n", data);

  259.                 ret = AVERROR_PATCHWELCOME;

  260.                 break;

  261.             }

  262.         } else if (tag == 14) {

  263.             av_log(avctx, AV_LOG_DEBUG, "Subband Count: %"PRIu16"\n", data);

  264.             if (data != SUBBAND_COUNT) {

  265.                 av_log(avctx, AV_LOG_ERROR, "Subband Count of %"PRIu16" is unsupported\n", data);

  266.                 ret = AVERROR_PATCHWELCOME;

  267.                 break;

  268.             }

  269.         } else if (tag == 62) {

  270.             s->channel_num = data;

  271.             av_log(avctx, AV_LOG_DEBUG, "Channel number %"PRIu16"\n", data);

  272.             if (s->channel_num > 2) {

  273.                 av_log(avctx, AV_LOG_ERROR, "Invalid channel number\n");

  274.                 ret = AVERROR(EINVAL);

  275.                 break;

  276.             }

  277.             init_plane_defaults(s);

  278.         } else if (tag == 48) {

  279.             if (s->subband_num != 0 && data == 1)  // hack

  280.                 s->level++;

  281.             av_log(avctx, AV_LOG_DEBUG, "Subband number %"PRIu16"\n", data);

  282.             s->subband_num = data;

  283.             if (s->level >= DWT_LEVELS) {

  284.                 av_log(avctx, AV_LOG_ERROR, "Invalid level\n");

  285.                 ret = AVERROR(EINVAL);

  286.                 break;

  287.             }

  288.             if (s->subband_num > 3) {

  289.                 av_log(avctx, AV_LOG_ERROR, "Invalid subband number\n");

  290.                 ret = AVERROR(EINVAL);

  291.                 break;

  292.             }

  293.         } else if (tag == 51) {

  294.             av_log(avctx, AV_LOG_DEBUG, "Subband number actual %"PRIu16"\n", data);

  295.             s->subband_num_actual = data;

  296.             if (s->subband_num_actual >= 10) {

  297.                 av_log(avctx, AV_LOG_ERROR, "Invalid subband number actual\n");

  298.                 ret = AVERROR(EINVAL);

  299.                 break;

  300.             }

  301.         } else if (tag == 35)

  302.             av_log(avctx, AV_LOG_DEBUG, "Lowpass precision bits: %"PRIu16"\n", data);

  303.         else if (tag == 53) {

  304.             s->quantisation = data;

  305.             av_log(avctx, AV_LOG_DEBUG, "Quantisation: %"PRIu16"\n", data);

  306.         } else if (tag == 109) {

  307.             s->prescale_shift[0] = (data >> 0) & 0x7;

  308.             s->prescale_shift[1] = (data >> 3) & 0x7;

  309.             s->prescale_shift[2] = (data >> 6) & 0x7;

  310.             av_log(avctx, AV_LOG_DEBUG, "Prescale shift (VC-5): %x\n", data);

  311.         } else if (tag == 27) {

  312.             s->plane[s->channel_num].band[0][0].width  = data;

  313.             s->plane[s->channel_num].band[0][0].stride = data;

  314.             av_log(avctx, AV_LOG_DEBUG, "Lowpass width %"PRIu16"\n", data);

  315.             if (data < 2 || data > s->plane[s->channel_num].band[0][0].a_width) {

  316.                 av_log(avctx, AV_LOG_ERROR, "Invalid lowpass width\n");

  317.                 ret = AVERROR(EINVAL);

  318.                 break;

  319.             }

  320.         } else if (tag == 28) {

  321.             s->plane[s->channel_num].band[0][0].height = data;

  322.             av_log(avctx, AV_LOG_DEBUG, "Lowpass height %"PRIu16"\n", data);

  323.             if (data < 2 || data > s->plane[s->channel_num].band[0][0].height) {

  324.                 av_log(avctx, AV_LOG_ERROR, "Invalid lowpass height\n");

  325.                 ret = AVERROR(EINVAL);

  326.                 break;

  327.             }

  328.         } else if (tag == 1)

  329.             av_log(avctx, AV_LOG_DEBUG, "Sample type? %"PRIu16"\n", data);

  330.         else if (tag == 10) {

  331.             if (data != 0) {

  332.                 avpriv_report_missing_feature(avctx, "Transform type of %"PRIu16" is unsupported\n", data);

  333.                 ret = AVERROR_PATCHWELCOME;

  334.                 break;

  335.             }

  336.             av_log(avctx, AV_LOG_DEBUG, "Transform-type? %"PRIu16"\n", data);

  337.         } else if (abstag >= 0x4000 && abstag <= 0x40ff) {

  338.             av_log(avctx, AV_LOG_DEBUG, "Small chunk length %"PRIu16" %s\n", data * 4, tag < 0 ? "optional" : "required");

  339.             bytestream2_skipu(&gb, data * 4);

  340.         } else if (tag == 23) {

  341.             av_log(avctx, AV_LOG_DEBUG, "Skip frame\n");

  342.             avpriv_report_missing_feature(avctx, "Skip frame not supported\n");

  343.             ret = AVERROR_PATCHWELCOME;

  344.             break;

  345.         } else if (tag == 2) {

  346.             av_log(avctx, AV_LOG_DEBUG, "tag=2 header - skipping %i tag/value pairs\n", data);

  347.             if (data > bytestream2_get_bytes_left(&gb) / 4) {

  348.                 av_log(avctx, AV_LOG_ERROR, "too many tag/value pairs (%d)\n", data);

  349.                 ret = AVERROR_INVALIDDATA;

  350.                 break;

  351.             }

  352.             for (i = 0; i < data; i++) {

  353.                 uint16_t tag2 = bytestream2_get_be16(&gb);

  354.                 uint16_t val2 = bytestream2_get_be16(&gb);

  355.                 av_log(avctx, AV_LOG_DEBUG, "Tag/Value = %x %x\n", tag2, val2);

  356.             }

  357.         } else if (tag == 41) {

  358.             s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;

  359.             s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);

  360.             av_log(avctx, AV_LOG_DEBUG, "Highpass width %i channel %i level %i subband %i\n", data, s->channel_num, s->level, s->subband_num);

  361.             if (data < 2) {

  362.                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass width\n");

  363.                 ret = AVERROR(EINVAL);

  364.                 break;

  365.             }

  366.         } else if (tag == 42) {

  367.             s->plane[s->channel_num].band[s->level][s->subband_num].height = data;

  368.             av_log(avctx, AV_LOG_DEBUG, "Highpass height %i\n", data);

  369.             if (data < 2) {

  370.                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass height\n");

  371.                 ret = AVERROR(EINVAL);

  372.                 break;

  373.             }

  374.         } else if (tag == 49) {

  375.             s->plane[s->channel_num].band[s->level][s->subband_num].width  = data;

  376.             s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);

  377.             av_log(avctx, AV_LOG_DEBUG, "Highpass width2 %i\n", data);

  378.             if (data < 2) {

  379.                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass width2\n");

  380.                 ret = AVERROR(EINVAL);

  381.                 break;

  382.             }

  383.         } else if (tag == 50) {

  384.             s->plane[s->channel_num].band[s->level][s->subband_num].height = data;

  385.             av_log(avctx, AV_LOG_DEBUG, "Highpass height2 %i\n", data);

  386.             if (data < 2) {

  387.                 av_log(avctx, AV_LOG_ERROR, "Invalid highpass height2\n");

  388.                 ret = AVERROR(EINVAL);

  389.                 break;

  390.             }

  391.         } else if (tag == 71) {

  392.             s->codebook = data;

  393.             av_log(avctx, AV_LOG_DEBUG, "Codebook %i\n", s->codebook);

  394.         } else if (tag == 72) {

  395.             s->codebook = data;

  396.             av_log(avctx, AV_LOG_DEBUG, "Other codebook? %i\n", s->codebook);

  397.         } else if (tag == 70) {

  398.             av_log(avctx, AV_LOG_DEBUG, "Subsampling or bit-depth flag? %i\n", data);

  399.             s->bpc = data;

  400.             if (!(s->bpc == 10 || s->bpc == 12)) {

  401.                 av_log(avctx, AV_LOG_ERROR, "Invalid bits per channel\n");

  402.                 ret = AVERROR(EINVAL);

  403.                 break;

  404.             }

  405.         } else if (tag == 84) {

  406.             av_log(avctx, AV_LOG_DEBUG, "Sample format? %i\n", data);

  407.             if (data == 1)

  408.                 avctx->pix_fmt = AV_PIX_FMT_YUV422P10;

  409.             else if (data == 3)

  410.                 avctx->pix_fmt = AV_PIX_FMT_GBRP12;

  411.             else {

  412.                 avpriv_report_missing_feature(avctx, "Sample format of %"PRIu16" is unsupported\n", data);

  413.                 ret = AVERROR_PATCHWELCOME;

  414.                 break;

  415.             }

  416.         } else

  417.             av_log(avctx, AV_LOG_DEBUG,  "Unknown tag %i data %x\n", tag, data);

  418. 

  419.         /* Some kind of end of header tag */

  420.         if (tag == 4 && data == 0x1a4a && s->coded_width && s->coded_height && avctx->pix_fmt != AV_PIX_FMT_NONE) {

  421.             if (s->a_width != s->coded_width || s->a_height != s->coded_height) {

  422.                 free_buffers(avctx);

  423.                 if ((ret = alloc_buffers(avctx)) < 0) {

  424.                     free_buffers(avctx);

  425.                     return ret;

  426.                 }

  427.             }

  428.             ret = ff_set_dimensions(avctx, s->coded_width, s->coded_height);

  429.             if (ret < 0)

  430.                 return ret;

  431.             frame.f->width =

  432.             frame.f->height = 0;

  433. 

  434.             if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

  435.                 return ret;

  436. 

  437.             s->coded_width = 0;

  438.             s->coded_height = 0;

  439.             got_buffer = 1;

  440.         }

  441.         coeff_data = s->plane[s->channel_num].subband[s->subband_num_actual];

  442. 

  443.         /* Lowpass coefficients */

  444.         if (tag == 4 && data == 0xf0f && s->a_width && s->a_height) {

  445.             int lowpass_height = s->plane[s->channel_num].band[0][0].height;

  446.             int lowpass_width  = s->plane[s->channel_num].band[0][0].width;

  447.             int lowpass_a_height = s->plane[s->channel_num].band[0][0].a_height;

  448.             int lowpass_a_width  = s->plane[s->channel_num].band[0][0].a_width;

  449. 

  450.             if (lowpass_height > lowpass_a_height || lowpass_width > lowpass_a_width ||

  451.                 lowpass_a_width * lowpass_a_height * sizeof(int16_t) > bytestream2_get_bytes_left(&gb)) {

  452.                 av_log(avctx, AV_LOG_ERROR, "Too many lowpass coefficients\n");

  453.                 ret = AVERROR(EINVAL);

  454.                 goto end;

  455.             }

  456. 

  457.             av_log(avctx, AV_LOG_DEBUG, "Start of lowpass coeffs component %"PRIu16" height:%d, width:%d\n", s->channel_num, lowpass_height, lowpass_width);

  458.             for (i = 0; i < lowpass_height; i++) {

  459.                 for (j = 0; j < lowpass_width; j++)

  460.                     coeff_data[j] = bytestream2_get_be16u(&gb);

  461. 

  462.                 coeff_data += lowpass_width;

  463.             }

  464. 

  465.             /* Copy last line of coefficients if odd height */

  466.             if (lowpass_height & 1) {

  467.                 memcpy(&coeff_data[lowpass_height * lowpass_width],

  468.                        &coeff_data[(lowpass_height - 1) * lowpass_width],

  469.                        lowpass_width * sizeof(*coeff_data));

  470.             }

  471. 

  472.             av_log(avctx, AV_LOG_DEBUG, "Lowpass coefficients %"PRIu16"\n", lowpass_width * lowpass_height);

  473.         }

  474. 

  475.         if (tag == 55 && s->subband_num_actual != 255 && s->a_width && s->a_height) {

  476.             int highpass_height = s->plane[s->channel_num].band[s->level][s->subband_num].height;

  477.             int highpass_width  = s->plane[s->channel_num].band[s->level][s->subband_num].width;

  478.             int highpass_a_width = s->plane[s->channel_num].band[s->level][s->subband_num].a_width;

  479.             int highpass_a_height = s->plane[s->channel_num].band[s->level][s->subband_num].a_height;

  480.             int highpass_stride = s->plane[s->channel_num].band[s->level][s->subband_num].stride;

  481.             int expected = highpass_height * highpass_stride;

  482.             int a_expected = highpass_a_height * highpass_a_width;

  483.             int level, run, coeff;

  484.             int count = 0, bytes;

  485. 

  486.             if (highpass_height > highpass_a_height || highpass_width > highpass_a_width || a_expected < expected) {

  487.                 av_log(avctx, AV_LOG_ERROR, "Too many highpass coefficents\n");

  488.                 ret = AVERROR(EINVAL);

  489.                 goto end;

  490.             }

  491. 

  492.             av_log(avctx, AV_LOG_DEBUG, "Start subband coeffs plane %i level %i codebook %i expected %i\n", s->channel_num, s->level, s->codebook, expected);

  493. 

  494.             init_get_bits(&s->gb, gb.buffer, bytestream2_get_bytes_left(&gb) * 8);

  495.             {

  496.                 OPEN_READER(re, &s->gb);

  497.                 if (!s->codebook) {

  498.                     while (1) {

  499.                         UPDATE_CACHE(re, &s->gb);

  500.                         GET_RL_VLC(level, run, re, &s->gb, s->table_9_rl_vlc,

  501.                                    VLC_BITS, 3, 1);

  502. 

  503.                         /* escape */

  504.                         if (level == 64)

  505.                             break;

  506. 

  507.                         count += run;

  508. 

  509.                         if (count > expected)

  510.                             break;

  511. 

  512.                         coeff = dequant_and_decompand(level, s->quantisation);

  513.                         for (i = 0; i < run; i++)

  514.                             *coeff_data++ = coeff;

  515.                     }

  516.                 } else {

  517.                     while (1) {

  518.                         UPDATE_CACHE(re, &s->gb);

  519.                         GET_RL_VLC(level, run, re, &s->gb, s->table_18_rl_vlc,

  520.                                    VLC_BITS, 3, 1);

  521. 

  522.                         /* escape */

  523.                         if (level == 255 && run == 2)

  524.                             break;

  525. 

  526.                         count += run;

  527. 

  528.                         if (count > expected)

  529.                             break;

  530. 

  531.                         coeff = dequant_and_decompand(level, s->quantisation);

  532.                         for (i = 0; i < run; i++)

  533.                             *coeff_data++ = coeff;

  534.                     }

  535.                 }

  536.                 CLOSE_READER(re, &s->gb);

  537.             }

  538. 

  539.             if (count > expected) {

  540.                 av_log(avctx, AV_LOG_ERROR, "Escape codeword not found, probably corrupt data\n");

  541.                 ret = AVERROR(EINVAL);

  542.                 goto end;

  543.             }

  544. 

  545.             bytes = FFALIGN(FF_CEIL_RSHIFT(get_bits_count(&s->gb), 3), 4);

  546.             if (bytes > bytestream2_get_bytes_left(&gb)) {

  547.                 av_log(avctx, AV_LOG_ERROR, "Bitstream overread error\n");

  548.                 ret = AVERROR(EINVAL);

  549.                 goto end;

  550.             } else

  551.                 bytestream2_seek(&gb, bytes, SEEK_CUR);

  552. 

  553.             av_log(avctx, AV_LOG_DEBUG, "End subband coeffs %i extra %i\n", count, count - expected);

  554.             s->codebook = 0;

  555. 

  556.             /* Copy last line of coefficients if odd height */

  557.             if (highpass_height & 1) {

  558.                 memcpy(&coeff_data[highpass_height * highpass_stride],

  559.                        &coeff_data[(highpass_height - 1) * highpass_stride],

  560.                        highpass_stride * sizeof(*coeff_data));

  561.             }

  562.         }

  563.     }

  564. 

  565.     if (!s->a_width || !s->a_height || s->coded_width || s->coded_height) {

  566.         av_log(avctx, AV_LOG_ERROR, "Invalid dimensions\n");

  567.         ret = AVERROR(EINVAL);

  568.         goto end;

  569.     }

  570. 

  571.     if (!got_buffer) {

  572.         av_log(avctx, AV_LOG_ERROR, "No end of header tag found\n");

  573.         ret = AVERROR(EINVAL);

  574.         goto end;

  575.     }

  576. 

  577.     for (plane = 0; plane < 3 && !ret; plane++) {

  578.         /* level 1 */

  579.         int lowpass_height  = s->plane[plane].band[0][0].height;

  580.         int lowpass_width   = s->plane[plane].band[0][0].width;

  581.         int highpass_stride = s->plane[plane].band[0][1].stride;

  582.         int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : 0;

  583.         int16_t *low, *high, *output, *dst;

  584. 

  585.         if (lowpass_height > s->plane[plane].band[0][0].a_height || lowpass_width > s->plane[plane].band[0][0].a_width ||

  586.             !highpass_stride || s->plane[plane].band[0][1].width > s->plane[plane].band[0][1].a_width) {

  587.             av_log(avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");

  588.             ret = AVERROR(EINVAL);

  589.             goto end;

  590.         }

  591. 

  592.         av_log(avctx, AV_LOG_DEBUG, "Decoding level 1 plane %i %i %i %i\n", plane, lowpass_height, lowpass_width, highpass_stride);

  593. 

  594.         low    = s->plane[plane].subband[0];

  595.         high   = s->plane[plane].subband[2];

  596.         output = s->plane[plane].l_h[0];

  597.         for (i = 0; i < lowpass_width; i++) {

  598.             vert_filter(output, lowpass_width, low, lowpass_width, high, highpass_stride, lowpass_height);

  599.             low++;

  600.             high++;

  601.             output++;

  602.         }

  603. 

  604.         low    = s->plane[plane].subband[1];

  605.         high   = s->plane[plane].subband[3];

  606.         output = s->plane[plane].l_h[1];

  607. 

  608.         for (i = 0; i < lowpass_width; i++) {

  609.             // note the stride of "low" is highpass_stride

  610.             vert_filter(output, lowpass_width, low, highpass_stride, high, highpass_stride, lowpass_height);

  611.             low++;

  612.             high++;

  613.             output++;

  614.         }

  615. 

  616.         low    = s->plane[plane].l_h[0];

  617.         high   = s->plane[plane].l_h[1];

  618.         output = s->plane[plane].subband[0];

  619.         for (i = 0; i < lowpass_height * 2; i++) {

  620.             horiz_filter(output, low, high, lowpass_width);

  621.             low    += lowpass_width;

  622.             high   += lowpass_width;

  623.             output += lowpass_width * 2;

  624.         }

  625.         if (avctx->pix_fmt == AV_PIX_FMT_GBRP12) {

  626.             output = s->plane[plane].subband[0];

  627.             for (i = 0; i < lowpass_height * 2; i++) {

  628.                 for (j = 0; j < lowpass_width * 2; j++)

  629.                     output[j] <<= 2;

  630. 

  631.                 output += lowpass_width * 2;

  632.             }

  633.         }

  634. 

  635.         /* level 2 */

  636.         lowpass_height  = s->plane[plane].band[1][1].height;

  637.         lowpass_width   = s->plane[plane].band[1][1].width;

  638.         highpass_stride = s->plane[plane].band[1][1].stride;

  639. 

  640.         if (lowpass_height > s->plane[plane].band[1][1].a_height || lowpass_width > s->plane[plane].band[1][1].a_width ||

  641.             !highpass_stride || s->plane[plane].band[1][1].width > s->plane[plane].band[1][1].a_width) {

  642.             av_log(avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");

  643.             ret = AVERROR(EINVAL);

  644.             goto end;

  645.         }

  646. 

  647.         av_log(avctx, AV_LOG_DEBUG, "Level 2 plane %i %i %i %i\n", plane, lowpass_height, lowpass_width, highpass_stride);

  648. 

  649.         low    = s->plane[plane].subband[0];

  650.         high   = s->plane[plane].subband[5];

  651.         output = s->plane[plane].l_h[3];

  652.         for (i = 0; i < lowpass_width; i++) {

  653.             vert_filter(output, lowpass_width, low, lowpass_width, high, highpass_stride, lowpass_height);

  654.             low++;

  655.             high++;

  656.             output++;

  657.         }

  658. 

  659.         low    = s->plane[plane].subband[4];

  660.         high   = s->plane[plane].subband[6];

  661.         output = s->plane[plane].l_h[4];

  662.         for (i = 0; i < lowpass_width; i++) {

  663.             vert_filter(output, lowpass_width, low, highpass_stride, high, highpass_stride, lowpass_height);

  664.             low++;

  665.             high++;

  666.             output++;

  667.         }

  668. 

  669.         low    = s->plane[plane].l_h[3];

  670.         high   = s->plane[plane].l_h[4];

  671.         output = s->plane[plane].subband[0];

  672.         for (i = 0; i < lowpass_height * 2; i++) {

  673.             horiz_filter(output, low, high, lowpass_width);

  674.             low    += lowpass_width;

  675.             high   += lowpass_width;

  676.             output += lowpass_width * 2;

  677.         }

  678. 

  679.         output = s->plane[plane].subband[0];

  680.         for (i = 0; i < lowpass_height * 2; i++) {

  681.             for (j = 0; j < lowpass_width * 2; j++)

  682.                 output[j] <<= 2;

  683. 

  684.             output += lowpass_width * 2;

  685.         }

  686. 

  687.         /* level 3 */

  688.         lowpass_height  = s->plane[plane].band[2][1].height;

  689.         lowpass_width   = s->plane[plane].band[2][1].width;

  690.         highpass_stride = s->plane[plane].band[2][1].stride;

  691. 

  692.         if (lowpass_height > s->plane[plane].band[2][1].a_height || lowpass_width > s->plane[plane].band[2][1].a_width ||

  693.             !highpass_stride || s->plane[plane].band[2][1].width > s->plane[plane].band[2][1].a_width) {

  694.             av_log(avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");

  695.             ret = AVERROR(EINVAL);

  696.             goto end;

  697.         }

  698. 

  699.         av_log(avctx, AV_LOG_DEBUG, "Level 3 plane %i %i %i %i\n", plane, lowpass_height, lowpass_width, highpass_stride);

  700. 

  701.         low    = s->plane[plane].subband[0];

  702.         high   = s->plane[plane].subband[8];

  703.         output = s->plane[plane].l_h[6];

  704.         for (i = 0; i < lowpass_width; i++) {

  705.             vert_filter(output, lowpass_width, low, lowpass_width, high, highpass_stride, lowpass_height);

  706.             low++;

  707.             high++;

  708.             output++;

  709.         }

  710. 

  711.         low    = s->plane[plane].subband[7];

  712.         high   = s->plane[plane].subband[9];

  713.         output = s->plane[plane].l_h[7];

  714.         for (i = 0; i < lowpass_width; i++) {

  715.             vert_filter(output, lowpass_width, low, highpass_stride, high, highpass_stride, lowpass_height);

  716.             low++;

  717.             high++;

  718.             output++;

  719.         }

  720. 

  721.         dst = (int16_t *)pic->data[act_plane];

  722.         low  = s->plane[plane].l_h[6];

  723.         high = s->plane[plane].l_h[7];

  724.         for (i = 0; i < lowpass_height * 2; i++) {

  725.             horiz_filter_clip(dst, low, high, lowpass_width, s->bpc);

  726.             low  += lowpass_width;

  727.             high += lowpass_width;

  728.             dst  += pic->linesize[act_plane] / 2;

  729.         }

  730.     }

  731. 

  732. 

  733. end:

  734.     if (ret < 0)

  735.         return ret;

  736. 

  737.     *got_frame = 1;

  738.     return avpkt->size;

  739. }

  740. 

  741. static av_cold int cfhd_close_decoder(AVCodecContext *avctx)

  742. {

  743.     CFHDContext *s = avctx->priv_data;

  744. 

  745.     free_buffers(avctx);

  746. 

  747.     if (!avctx->internal->is_copy) {

  748.         ff_free_vlc(&s->vlc_9);

  749.         ff_free_vlc(&s->vlc_18);

  750.     }

  751. 

  752.     return 0;

  753. }

  754. 

  755. AVCodec ff_cfhd_decoder = {

  756.     .name           = "cfhd",

  757.     .long_name      = NULL_IF_CONFIG_SMALL("Cineform HD"),

  758.     .type           = AVMEDIA_TYPE_VIDEO,

  759.     .id             = AV_CODEC_ID_CFHD,

  760.     .priv_data_size = sizeof(CFHDContext),

  761.     .init           = cfhd_decode_init,

  762.     .close          = cfhd_close_decoder,

  763.     .decode         = cfhd_decode,

  764.     .capabilities   = AV_CODEC_CAP_DR1,

  765.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

  766. };