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

803 lines
31KB
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. 

  47.     return ff_cfhd_init_vlcs(s);

  48. }

  49. 

  50. static void init_plane_defaults(CFHDContext *s)

  51. {

  52.     s->subband_num        = 0;

  53.     s->level              = 0;

  54.     s->subband_num_actual = 0;

  55. }

  56. 

  57. static void init_frame_defaults(CFHDContext *s)

  58. {

  59.     s->coded_width       = 0;

  60.     s->coded_height      = 0;

  61.     s->bpc               = 10;

  62.     s->channel_cnt       = 4;

  63.     s->subband_cnt       = 10;

  64.     s->channel_num       = 0;

  65.     s->lowpass_precision = 16;

  66.     s->quantisation      = 1;

  67.     s->wavelet_depth     = 3;

  68.     s->pshift            = 1;

  69.     s->codebook          = 0;

  70.     init_plane_defaults(s);

  71. }

  72. 

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

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

  75. {

  76.     int64_t abslevel = abs(level);

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

  78. }

  79. 

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

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

  82. {

  83.     int16_t tmp;

  84. 

  85.     int i;

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

  87.         if (i == 0) {

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

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

  90.             if (clip)

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

  92. 

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

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

  95.             if (clip)

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

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

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

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

  100.             if (clip)

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

  102. 

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

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

  105.             if (clip)

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

  107.         } else {

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

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

  110.             if (clip)

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

  112. 

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

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

  115.             if (clip)

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

  117.         }

  118.     }

  119. }

  120. 

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

  122. {

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

  124. }

  125. 

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

  127. {

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

  129. }

  130. 

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

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

  133. {

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

  135. }

  136. 

  137. static void free_buffers(AVCodecContext *avctx)

  138. {

  139.     CFHDContext *s = avctx->priv_data;

  140.     int i, j;

  141. 

  142.     for (i = 0; i < 4; i++) {

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

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

  145. 

  146.         for (j = 0; j < 9; j++)

  147.             s->plane[i].subband[j] = NULL;

  148. 

  149.         for (j = 0; j < 8; j++)

  150.             s->plane[i].l_h[j] = NULL;

  151.     }

  152.     s->a_height = 0;

  153.     s->a_width  = 0;

  154. }

  155. 

  156. static int alloc_buffers(AVCodecContext *avctx)

  157. {

  158.     CFHDContext *s = avctx->priv_data;

  159.     int i, j, k, ret, planes;

  160. 

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

  162.         return ret;

  163.     avctx->pix_fmt = s->coded_format;

  164. 

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

  166.     planes = av_pix_fmt_count_planes(avctx->pix_fmt);

  167. 

  168.     for (i = 0; i < planes; i++) {

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

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

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

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

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

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

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

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

  177. 

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

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

  180.         w4 = w8 * 2;

  181.         h4 = h8 * 2;

  182.         w2 = w4 * 2;

  183.         h2 = h4 * 2;

  184. 

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

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

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

  188.             return AVERROR(ENOMEM);

  189.         }

  190. 

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

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

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

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

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

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

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

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

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

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

  201. 

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

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

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

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

  206.             }

  207.         }

  208. 

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

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

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

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

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

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

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

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

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

  218.     }

  219. 

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

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

  222.     s->a_format = s->coded_format;

  223. 

  224.     return 0;

  225. }

  226. 

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

  228.                        AVPacket *avpkt)

  229. {

  230.     CFHDContext *s = avctx->priv_data;

  231.     GetByteContext gb;

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

  233.     AVFrame *pic = data;

  234.     int ret = 0, i, j, planes, plane, got_buffer = 0;

  235.     int16_t *coeff_data;

  236. 

  237.     s->coded_format = AV_PIX_FMT_YUV422P10;

  238.     init_frame_defaults(s);

  239.     planes = av_pix_fmt_count_planes(s->coded_format);

  240. 

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

  242. 

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

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

  245.         uint16_t tagu   = bytestream2_get_be16(&gb);

  246.         int16_t tag     = (int16_t)tagu;

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

  248.         uint16_t abstag = abs(tag);

  249.         int8_t abs_tag8 = abs(tag8);

  250.         uint16_t data   = bytestream2_get_be16(&gb);

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

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

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

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

  255.             s->coded_width = data;

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

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

  258.             s->coded_height = data;

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

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

  261.             if (data < 1 || data > 31) {

  262.                 av_log(avctx, AV_LOG_ERROR, "Bits per component %d is invalid\n", data);

  263.                 ret = AVERROR(EINVAL);

  264.                 break;

  265.             }

  266.             s->bpc = data;

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

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

  269.             s->channel_cnt = data;

  270.             if (data > 4) {

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

  272.                 ret = AVERROR_PATCHWELCOME;

  273.                 break;

  274.             }

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

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

  277.             if (data != SUBBAND_COUNT) {

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

  279.                 ret = AVERROR_PATCHWELCOME;

  280.                 break;

  281.             }

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

  283.             s->channel_num = data;

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

  285.             if (s->channel_num >= planes) {

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

  287.                 ret = AVERROR(EINVAL);

  288.                 break;

  289.             }

  290.             init_plane_defaults(s);

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

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

  293.                 s->level++;

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

  295.             s->subband_num = data;

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

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

  298.                 ret = AVERROR(EINVAL);

  299.                 break;

  300.             }

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

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

  303.                 ret = AVERROR(EINVAL);

  304.                 break;

  305.             }

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

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

  308.             s->subband_num_actual = data;

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

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

  311.                 ret = AVERROR(EINVAL);

  312.                 break;

  313.             }

  314.         } else if (tag == 35)

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

  316.         else if (tag == 53) {

  317.             s->quantisation = data;

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

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

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

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

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

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

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

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

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

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

  328.                 ret = AVERROR(EINVAL);

  329.                 break;

  330.             }

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

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

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

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

  335.             if (data < 3 || data > s->plane[s->channel_num].band[0][0].a_height) {

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

  337.                 ret = AVERROR(EINVAL);

  338.                 break;

  339.             }

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

  341.         } else if (tag == 1)

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

  343.         else if (tag == 10) {

  344.             if (data != 0) {

  345.                 avpriv_report_missing_feature(avctx, "Transform type of %"PRIu16, data);

  346.                 ret = AVERROR_PATCHWELCOME;

  347.                 break;

  348.             }

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

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

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

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

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

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

  355.             avpriv_report_missing_feature(avctx, "Skip frame");

  356.             ret = AVERROR_PATCHWELCOME;

  357.             break;

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

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

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

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

  362.                 ret = AVERROR_INVALIDDATA;

  363.                 break;

  364.             }

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

  366.                 uint16_t tag2 = bytestream2_get_be16(&gb);

  367.                 uint16_t val2 = bytestream2_get_be16(&gb);

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

  369.             }

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

  371.             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);

  372.             if (data < 3) {

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

  374.                 ret = AVERROR(EINVAL);

  375.                 break;

  376.             }

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

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

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

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

  381.             if (data < 3) {

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

  383.                 ret = AVERROR(EINVAL);

  384.                 break;

  385.             }

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

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

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

  389.             if (data < 3) {

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

  391.                 ret = AVERROR(EINVAL);

  392.                 break;

  393.             }

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

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

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

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

  398.             if (data < 3) {

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

  400.                 ret = AVERROR(EINVAL);

  401.                 break;

  402.             }

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

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

  405.             s->codebook = data;

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

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

  408.             s->codebook = data;

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

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

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

  412.             if (!(data == 10 || data == 12)) {

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

  414.                 ret = AVERROR(EINVAL);

  415.                 break;

  416.             }

  417.             s->bpc = data;

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

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

  420.             if (data == 1)

  421.                 s->coded_format = AV_PIX_FMT_YUV422P10;

  422.             else if (data == 3)

  423.                 s->coded_format = AV_PIX_FMT_GBRP12;

  424.             else if (data == 4)

  425.                 s->coded_format = AV_PIX_FMT_GBRAP12;

  426.             else {

  427.                 avpriv_report_missing_feature(avctx, "Sample format of %"PRIu16, data);

  428.                 ret = AVERROR_PATCHWELCOME;

  429.                 break;

  430.             }

  431.             planes = av_pix_fmt_count_planes(s->coded_format);

  432.         } else

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

  434. 

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

  436.         if (tag == 4 && data == 0x1a4a && s->coded_width && s->coded_height &&

  437.             s->coded_format != AV_PIX_FMT_NONE) {

  438.             if (s->a_width != s->coded_width || s->a_height != s->coded_height ||

  439.                 s->a_format != s->coded_format) {

  440.                 free_buffers(avctx);

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

  442.                     free_buffers(avctx);

  443.                     return ret;

  444.                 }

  445.             }

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

  447.             if (ret < 0)

  448.                 return ret;

  449.             frame.f->width =

  450.             frame.f->height = 0;

  451. 

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

  453.                 return ret;

  454. 

  455.             s->coded_width = 0;

  456.             s->coded_height = 0;

  457.             s->coded_format = AV_PIX_FMT_NONE;

  458.             got_buffer = 1;

  459.         }

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

  461. 

  462.         /* Lowpass coefficients */

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

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

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

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

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

  468. 

  469.             if (!got_buffer) {

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

  471.                 ret = AVERROR(EINVAL);

  472.                 goto end;

  473.             }

  474. 

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

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

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

  478.                 ret = AVERROR(EINVAL);

  479.                 goto end;

  480.             }

  481. 

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

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

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

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

  486. 

  487.                 coeff_data += lowpass_width;

  488.             }

  489. 

  490.             /* Align to mod-4 position to continue reading tags */

  491.             bytestream2_seek(&gb, bytestream2_tell(&gb) & 3, SEEK_CUR);

  492. 

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

  494.             if (lowpass_height & 1) {

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

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

  497.                        lowpass_width * sizeof(*coeff_data));

  498.             }

  499. 

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

  501.         }

  502. 

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

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

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

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

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

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

  509.             int expected = highpass_height * highpass_stride;

  510.             int a_expected = highpass_a_height * highpass_a_width;

  511.             int level, run, coeff;

  512.             int count = 0, bytes;

  513. 

  514.             if (!got_buffer) {

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

  516.                 ret = AVERROR(EINVAL);

  517.                 goto end;

  518.             }

  519. 

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

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

  522.                 ret = AVERROR(EINVAL);

  523.                 goto end;

  524.             }

  525. 

  526.             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);

  527. 

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

  529.             {

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

  531.                 if (!s->codebook) {

  532.                     while (1) {

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

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

  535.                                    VLC_BITS, 3, 1);

  536. 

  537.                         /* escape */

  538.                         if (level == 64)

  539.                             break;

  540. 

  541.                         count += run;

  542. 

  543.                         if (count > expected)

  544.                             break;

  545. 

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

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

  548.                             *coeff_data++ = coeff;

  549.                     }

  550.                 } else {

  551.                     while (1) {

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

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

  554.                                    VLC_BITS, 3, 1);

  555. 

  556.                         /* escape */

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

  558.                             break;

  559. 

  560.                         count += run;

  561. 

  562.                         if (count > expected)

  563.                             break;

  564. 

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

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

  567.                             *coeff_data++ = coeff;

  568.                     }

  569.                 }

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

  571.             }

  572. 

  573.             if (count > expected) {

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

  575.                 ret = AVERROR(EINVAL);

  576.                 goto end;

  577.             }

  578. 

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

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

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

  582.                 ret = AVERROR(EINVAL);

  583.                 goto end;

  584.             } else

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

  586. 

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

  588.             s->codebook = 0;

  589. 

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

  591.             if (highpass_height & 1) {

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

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

  594.                        highpass_stride * sizeof(*coeff_data));

  595.             }

  596.         }

  597.     }

  598. 

  599.     if (!s->a_width || !s->a_height || s->a_format == AV_PIX_FMT_NONE ||

  600.         s->coded_width || s->coded_height || s->coded_format != AV_PIX_FMT_NONE) {

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

  602.         ret = AVERROR(EINVAL);

  603.         goto end;

  604.     }

  605. 

  606.     if (!got_buffer) {

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

  608.         ret = AVERROR(EINVAL);

  609.         goto end;

  610.     }

  611. 

  612.     planes = av_pix_fmt_count_planes(avctx->pix_fmt);

  613.     for (plane = 0; plane < planes && !ret; plane++) {

  614.         /* level 1 */

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

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

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

  618.         int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;

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

  620. 

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

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

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

  624.             ret = AVERROR(EINVAL);

  625.             goto end;

  626.         }

  627. 

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

  629. 

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

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

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

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

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

  635.             low++;

  636.             high++;

  637.             output++;

  638.         }

  639. 

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

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

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

  643. 

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

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

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

  647.             low++;

  648.             high++;

  649.             output++;

  650.         }

  651. 

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

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

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

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

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

  657.             low    += lowpass_width;

  658.             high   += lowpass_width;

  659.             output += lowpass_width * 2;

  660.         }

  661.         if (s->bpc == 12) {

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

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

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

  665.                     output[j] *= 4;

  666. 

  667.                 output += lowpass_width * 2;

  668.             }

  669.         }

  670. 

  671.         /* level 2 */

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

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

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

  675. 

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

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

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

  679.             ret = AVERROR(EINVAL);

  680.             goto end;

  681.         }

  682. 

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

  684. 

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

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

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

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

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

  690.             low++;

  691.             high++;

  692.             output++;

  693.         }

  694. 

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

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

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

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

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

  700.             low++;

  701.             high++;

  702.             output++;

  703.         }

  704. 

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

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

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

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

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

  710.             low    += lowpass_width;

  711.             high   += lowpass_width;

  712.             output += lowpass_width * 2;

  713.         }

  714. 

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

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

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

  718.                 output[j] *= 4;

  719. 

  720.             output += lowpass_width * 2;

  721.         }

  722. 

  723.         /* level 3 */

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

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

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

  727. 

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

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

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

  731.             ret = AVERROR(EINVAL);

  732.             goto end;

  733.         }

  734. 

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

  736. 

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

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

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

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

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

  742.             low++;

  743.             high++;

  744.             output++;

  745.         }

  746. 

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

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

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

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

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

  752.             low++;

  753.             high++;

  754.             output++;

  755.         }

  756. 

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

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

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

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

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

  762.             low  += lowpass_width;

  763.             high += lowpass_width;

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

  765.         }

  766.     }

  767. 

  768. 

  769. end:

  770.     if (ret < 0)

  771.         return ret;

  772. 

  773.     *got_frame = 1;

  774.     return avpkt->size;

  775. }

  776. 

  777. static av_cold int cfhd_close_decoder(AVCodecContext *avctx)

  778. {

  779.     CFHDContext *s = avctx->priv_data;

  780. 

  781.     free_buffers(avctx);

  782. 

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

  784.         ff_free_vlc(&s->vlc_9);

  785.         ff_free_vlc(&s->vlc_18);

  786.     }

  787. 

  788.     return 0;

  789. }

  790. 

  791. AVCodec ff_cfhd_decoder = {

  792.     .name           = "cfhd",

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

  794.     .type           = AVMEDIA_TYPE_VIDEO,

  795.     .id             = AV_CODEC_ID_CFHD,

  796.     .priv_data_size = sizeof(CFHDContext),

  797.     .init           = cfhd_decode_init,

  798.     .close          = cfhd_close_decoder,

  799.     .decode         = cfhd_decode,

  800.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  801.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

  802. };