Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add Cineform HD Decoder

Browse Source 
Decodes YUV 4:2:2 10-bit and RGB 12-bit files.
Older files with more subbands, skips, Bayer, alpha not supported.

Further fixes and refactorings by Anton Khirnov <anton@khirnov.net>,
Diego Biurrun <diego@biurrun.de>, Vittorio Giovara <vittorio.giovara@gmail.com>

Signed-off-by: Diego Biurrun <diego@biurrun.de>
pull/272/head
Kieran Kunhya 9 years ago committed by Luca Barbato
parent f6790b5e10
commit 5f794aa165
11 changed files with 1229 additions and 1 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      Changelog
  2. 1
      doc/general.texi
  3. 1
      libavcodec/Makefile
  4. 1
      libavcodec/allcodecs.c
  5. 1
      libavcodec/avcodec.h
  6. 770
      libavcodec/cfhd.c
  7. 108
      libavcodec/cfhd.h
  8. 337
      libavcodec/cfhddata.c
  9. 7
      libavcodec/codec_desc.c
  10. 2
      libavcodec/version.h
  11. 1
      libavformat/riff.c

1
Changelog
Unescape View File

@ -11,6 +11,7 @@ version <next>:
- Apple Pixlet decoder
- The x86 assembler default switched from yasm to nasm, pass
--x86asmexe=yasm to configure to restore the old behavior.
- Cineform HD decoder
version 12:

1
doc/general.texi
Unescape View File

@ -626,6 +626,7 @@ following image formats are supported:
@tab Amiga CD video codec
@item Chinese AVS video @tab E @tab X
@tab AVS1-P2, JiZhun profile, encoding through external library libxavs
@item Cineform HD @tab @tab X
@item Delphine Software International CIN video @tab @tab X
@tab Codec used in Delphine Software International games.
@item Discworld II BMV Video @tab @tab X

1
libavcodec/Makefile
Unescape View File

@ -180,6 +180,7 @@ OBJS-$(CONFIG_CAVS_DECODER) += cavs.o cavsdec.o cavsdsp.o \
cavsdata.o mpeg12data.o
OBJS-$(CONFIG_CDGRAPHICS_DECODER) += cdgraphics.o
OBJS-$(CONFIG_CDXL_DECODER) += cdxl.o
OBJS-$(CONFIG_CFHD_DECODER) += cfhd.o cfhddata.o
OBJS-$(CONFIG_CINEPAK_DECODER) += cinepak.o
OBJS-$(CONFIG_CLJR_DECODER) += cljrdec.o
OBJS-$(CONFIG_CLJR_ENCODER) += cljrenc.o

1
libavcodec/allcodecs.c
Unescape View File

@ -127,6 +127,7 @@ void avcodec_register_all(void)
REGISTER_DECODER(CAVS, cavs);
REGISTER_DECODER(CDGRAPHICS, cdgraphics);
REGISTER_DECODER(CDXL, cdxl);
REGISTER_DECODER(CFHD, cfhd);
REGISTER_DECODER(CINEPAK, cinepak);
REGISTER_ENCDEC (CLJR, cljr);
REGISTER_DECODER(CLLC, cllc);

1
libavcodec/avcodec.h
Unescape View File

@ -415,6 +415,7 @@ enum AVCodecID {
AV_CODEC_ID_TRUEMOTION2RT,
AV_CODEC_ID_AV1,
AV_CODEC_ID_PIXLET,
AV_CODEC_ID_CFHD,
/* various PCM "codecs" */
AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs

770
libavcodec/cfhd.c
Unescape View File

@ -0,0 +1,770 @@
/*
* Copyright (c) 2015-2016 Kieran Kunhya <kieran@kunhya.com>
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* Cineform HD video decoder
*/
#include "libavutil/attributes.h"
#include "libavutil/buffer.h"
#include "libavutil/common.h"
#include "libavutil/imgutils.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/opt.h"
#include "avcodec.h"
#include "bitstream.h"
#include "bytestream.h"
#include "internal.h"
#include "thread.h"
#include "cfhd.h"
enum CFHDParam {
ChannelCount = 12,
SubbandCount = 14,
ImageWidth = 20,
ImageHeight = 21,
LowpassPrecision = 35,
SubbandNumber = 48,
Quantization = 53,
ChannelNumber = 62,
BitsPerComponent = 101,
ChannelWidth = 104,
ChannelHeight = 105,
PrescaleShift = 109,
};
static av_cold int cfhd_init(AVCodecContext *avctx)
{
CFHDContext *s = avctx->priv_data;
memset(s, 0, sizeof(*s));
s->avctx = avctx;
avctx->bits_per_raw_sample = 10;
return ff_cfhd_init_vlcs(s);
}
static void init_plane_defaults(CFHDContext *s)
{
s->subband_num = 0;
s->level = 0;
s->subband_num_actual = 0;
}
static void init_frame_defaults(CFHDContext *s)
{
s->coded_format = AV_PIX_FMT_YUV422P10;
s->coded_width = 0;
s->coded_height = 0;
s->cropped_height = 0;
s->bpc = 10;
s->channel_cnt = 4;
s->subband_cnt = SUBBAND_COUNT;
s->channel_num = 0;
s->lowpass_precision = 16;
s->quantisation = 1;
s->prescale_shift[0] = 0;
s->prescale_shift[1] = 0;
s->prescale_shift[2] = 0;
s->wavelet_depth = 3;
s->pshift = 1;
s->codebook = 0;
init_plane_defaults(s);
}
/* TODO: merge with VLC tables or use LUT */
static inline int dequant_and_decompand(int level, int quantisation)
{
int64_t abslevel = abs(level);
return (abslevel + ((768 * abslevel * abslevel * abslevel) / (255 * 255 * 255))) *
FFSIGN(level) * quantisation;
}
static inline void filter(int16_t *output, ptrdiff_t out_stride,
int16_t *low, ptrdiff_t low_stride,
int16_t *high, ptrdiff_t high_stride,
int len, int clip)
{
int16_t tmp;
int i;
for (i = 0; i < len; i++) {
if (i == 0) {
tmp = (11 * low[0 * low_stride] - 4 * low[1 * low_stride] + low[2 * low_stride] + 4) >> 3;
output[(2 * i + 0) * out_stride] = (tmp + high[0 * high_stride]) >> 1;
} else if (i == len - 1) {
tmp = (5 * low[i * low_stride] + 4 * low[(i - 1) * low_stride] - low[(i - 2) * low_stride] + 4) >> 3;
output[(2 * i + 0) * out_stride] = (tmp + high[i * high_stride]) >> 1;
} else {
tmp = (low[(i - 1) * low_stride] - low[(i + 1) * low_stride] + 4) >> 3;
output[(2 * i + 0) * out_stride] = (tmp + low[i * low_stride] + high[i * high_stride]) >> 1;
}
if (clip)
output[(2 * i + 0) * out_stride] = av_clip_uintp2_c(output[(2 * i + 0) * out_stride], clip);
if (i == 0) {
tmp = (5 * low[0 * low_stride] + 4 * low[1 * low_stride] - low[2 * low_stride] + 4) >> 3;
output[(2 * i + 1) * out_stride] = (tmp - high[0 * high_stride]) >> 1;
} else if (i == len - 1) {
tmp = (11 * low[i * low_stride] - 4 * low[(i - 1) * low_stride] + low[(i - 2) * low_stride] + 4) >> 3;
output[(2 * i + 1) * out_stride] = (tmp - high[i * high_stride]) >> 1;
} else {
tmp = (low[(i + 1) * low_stride] - low[(i - 1) * low_stride] + 4) >> 3;
output[(2 * i + 1) * out_stride] = (tmp + low[i * low_stride] - high[i * high_stride]) >> 1;
}
if (clip)
output[(2 * i + 1) * out_stride] = av_clip_uintp2_c(output[(2 * i + 1) * out_stride], clip);
}
}
static void horiz_filter(int16_t *output, int16_t *low, int16_t *high,
int width)
{
filter(output, 1, low, 1, high, 1, width, 0);
}
static void horiz_filter_clip(int16_t *output, int16_t *low, int16_t *high,
int width, int clip)
{
filter(output, 1, low, 1, high, 1, width, clip);
}
static void vert_filter(int16_t *output, ptrdiff_t out_stride,
int16_t *low, ptrdiff_t low_stride,
int16_t *high, ptrdiff_t high_stride, int len)
{
filter(output, out_stride, low, low_stride, high, high_stride, len, 0);
}
static void free_buffers(CFHDContext *s)
{
unsigned i;
for (i = 0; i < FF_ARRAY_ELEMS(s->plane); i++) {
av_freep(&s->plane[i].idwt_buf);
av_freep(&s->plane[i].idwt_tmp);
}
s->a_height = 0;
s->a_width = 0;
}
static int alloc_buffers(CFHDContext *s)
{
int i, j, ret, planes;
int chroma_x_shift, chroma_y_shift;
unsigned k;
if ((ret = av_pix_fmt_get_chroma_sub_sample(s->coded_format,
&chroma_x_shift,
&chroma_y_shift)) < 0)
return ret;
planes = av_pix_fmt_count_planes(s->coded_format);
for (i = 0; i < planes; i++) {
int w8, h8, w4, h4, w2, h2;
int width = i ? s->coded_width >> chroma_x_shift : s->coded_width;
int height = i ? s->coded_height >> chroma_y_shift : s->coded_height;
ptrdiff_t stride = FFALIGN(width / 8, 8) * 8;
height = FFALIGN(height / 8, 2) * 8;
s->plane[i].width = width;
s->plane[i].height = height;
s->plane[i].stride = stride;
w8 = FFALIGN(s->plane[i].width / 8, 8);
h8 = FFALIGN(s->plane[i].height / 8, 2);
w4 = w8 * 2;
h4 = h8 * 2;
w2 = w4 * 2;
h2 = h4 * 2;
s->plane[i].idwt_buf =
av_malloc_array(height * stride, sizeof(*s->plane[i].idwt_buf));
s->plane[i].idwt_tmp =
av_malloc_array(height * stride, sizeof(*s->plane[i].idwt_tmp));
if (!s->plane[i].idwt_buf || !s->plane[i].idwt_tmp)
return AVERROR(ENOMEM);
s->plane[i].subband[0] = s->plane[i].idwt_buf;
s->plane[i].subband[1] = s->plane[i].idwt_buf + 2 * w8 * h8;
s->plane[i].subband[2] = s->plane[i].idwt_buf + 1 * w8 * h8;
s->plane[i].subband[3] = s->plane[i].idwt_buf + 3 * w8 * h8;
s->plane[i].subband[4] = s->plane[i].idwt_buf + 2 * w4 * h4;
s->plane[i].subband[5] = s->plane[i].idwt_buf + 1 * w4 * h4;
s->plane[i].subband[6] = s->plane[i].idwt_buf + 3 * w4 * h4;
s->plane[i].subband[7] = s->plane[i].idwt_buf + 2 * w2 * h2;
s->plane[i].subband[8] = s->plane[i].idwt_buf + 1 * w2 * h2;
s->plane[i].subband[9] = s->plane[i].idwt_buf + 3 * w2 * h2;
for (j = 0; j < DWT_LEVELS; j++) {
for (k = 0; k < FF_ARRAY_ELEMS(s->plane[i].band[j]); k++) {
s->plane[i].band[j][k].a_width = w8 << j;
s->plane[i].band[j][k].a_height = h8 << j;
}
}
/* ll2 and ll1 commented out because they are done in-place */
s->plane[i].l_h[0] = s->plane[i].idwt_tmp;
s->plane[i].l_h[1] = s->plane[i].idwt_tmp + 2 * w8 * h8;
// s->plane[i].l_h[2] = ll2;
s->plane[i].l_h[3] = s->plane[i].idwt_tmp;
s->plane[i].l_h[4] = s->plane[i].idwt_tmp + 2 * w4 * h4;
// s->plane[i].l_h[5] = ll1;
s->plane[i].l_h[6] = s->plane[i].idwt_tmp;
s->plane[i].l_h[7] = s->plane[i].idwt_tmp + 2 * w2 * h2;
}
s->a_height = s->coded_height;
s->a_width = s->coded_width;
s->a_format = s->coded_format;
return 0;
}
static int parse_tag(CFHDContext *s, GetByteContext *gb,
int16_t *tag_, uint16_t *value, int *planes)
{
/* Bit weird but implement the tag parsing as the spec says */
uint16_t tagu = bytestream2_get_be16(gb);
int16_t tag = tagu;
int8_t tag8 = tagu >> 8;
uint16_t abstag = abs(tag);
int8_t abs_tag8 = abs(tag8);
uint16_t data = bytestream2_get_be16(gb);
*tag_ = tag;
*value = data;
if (abs_tag8 >= 0x60 && abs_tag8 <= 0x6F) {
av_log(s->avctx, AV_LOG_DEBUG, "large len %"PRIX16"\n",
((tagu & 0xFF) << 16) | data);
return 0;
} else if (abstag >= 0x4000 && abstag <= 0x40FF) {
av_log(s->avctx, AV_LOG_DEBUG, "Small chunk length %"PRIu16" %s\n",
data * 4, tag < 0 ? "optional" : "required");
bytestream2_skipu(gb, data * 4);
return 0;
}
switch (tag) {
case 1:
av_log(s->avctx, AV_LOG_DEBUG, "Sample type? %"PRIu16"\n", data);
break;
case 2:
{
int i;
av_log(s->avctx, AV_LOG_DEBUG,
"tag=2 header - skipping %"PRIu16" tag/value pairs\n", data);
if (data > bytestream2_get_bytes_left(gb) / 4) {
av_log(s->avctx, AV_LOG_ERROR,
"Too many tag/value pairs (%"PRIu16")\n", data);
return AVERROR_INVALIDDATA;
}
for (i = 0; i < data; i++) {
uint16_t tag2 = bytestream2_get_be16(gb);
uint16_t val2 = bytestream2_get_be16(gb);
av_log(s->avctx, AV_LOG_DEBUG, "Tag/Value = %"PRIX16" %"PRIX16"\n",
tag2, val2);
}
break;
}
case 10:
if (data != 0) {
avpriv_report_missing_feature(s->avctx, "Transform type %"PRIu16, data);
return AVERROR_PATCHWELCOME;
}
av_log(s->avctx, AV_LOG_DEBUG, "Transform-type? %"PRIu16"\n", data);
break;
case ChannelCount:
av_log(s->avctx, AV_LOG_DEBUG, "Channel count: %"PRIu16"\n", data);
if (data > 4) {
avpriv_report_missing_feature(s->avctx, "Channel count %"PRIu16, data);
return AVERROR_PATCHWELCOME;
}
s->channel_cnt = data;
break;
case SubbandCount:
av_log(s->avctx, AV_LOG_DEBUG, "Subband count: %"PRIu16"\n", data);
if (data != SUBBAND_COUNT) {
avpriv_report_missing_feature(s->avctx, "Subband count %"PRIu16, data);
return AVERROR_PATCHWELCOME;
}
break;
case ImageWidth:
av_log(s->avctx, AV_LOG_DEBUG, "Width %"PRIu16"\n", data);
s->coded_width = data;
break;
case ImageHeight:
av_log(s->avctx, AV_LOG_DEBUG, "Height %"PRIu16"\n", data);
s->coded_height = data;
break;
case 23:
avpriv_report_missing_feature(s->avctx, "Skip frame");
return AVERROR_PATCHWELCOME;
case 27:
av_log(s->avctx, AV_LOG_DEBUG, "Lowpass width %"PRIu16"\n", data);
if (data < 2 || data > s->plane[s->channel_num].band[0][0].a_width) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid lowpass width\n");
return AVERROR_INVALIDDATA;
}
s->plane[s->channel_num].band[0][0].width = data;
s->plane[s->channel_num].band[0][0].stride = data;
break;
case 28:
av_log(s->avctx, AV_LOG_DEBUG, "Lowpass height %"PRIu16"\n", data);
if (data < 2 || data > s->plane[s->channel_num].band[0][0].a_height) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid lowpass height\n");
return AVERROR_INVALIDDATA;
}
s->plane[s->channel_num].band[0][0].height = data;
break;
case LowpassPrecision:
av_log(s->avctx, AV_LOG_DEBUG, "Lowpass precision bits: %"PRIu16"\n", data);
break;
case 41:
case 49:
av_log(s->avctx, AV_LOG_DEBUG,
"Highpass width%s %"PRIu16" channel %i level %i subband %i\n",
tag == 49 ? "2" : "", data,
s->channel_num, s->level, s->subband_num);
if (data < 2) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid highpass width%s\n", tag == 49 ? "2" : "");
return AVERROR_INVALIDDATA;
}
s->plane[s->channel_num].band[s->level][s->subband_num].width = data;
s->plane[s->channel_num].band[s->level][s->subband_num].stride = FFALIGN(data, 8);
break;
case 42:
case 50:
av_log(s->avctx, AV_LOG_DEBUG, "Highpass height%s %"PRIu16"\n", tag == 50 ? "2" : "", data);
if (data < 2) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid highpass height%s\n", tag == 50 ? "2" : "");
return AVERROR_INVALIDDATA;
}
s->plane[s->channel_num].band[s->level][s->subband_num].height = data;
break;
case SubbandNumber:
av_log(s->avctx, AV_LOG_DEBUG, "Subband number %"PRIu16"\n", data);
if (data > 3) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid subband number\n");
return AVERROR_INVALIDDATA;
}
if (s->subband_num != 0 && data == 1) {
if (s->level + 1 >= DWT_LEVELS) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid level\n");
return AVERROR_INVALIDDATA;
}
s->level++;
}
s->subband_num = data;
break;
case 51:
av_log(s->avctx, AV_LOG_DEBUG, "Subband number actual %"PRIu16"\n", data);
if (data >= SUBBAND_COUNT) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid subband number actual\n");
return AVERROR_INVALIDDATA;
}
s->subband_num_actual = data;
break;
case Quantization:
s->quantisation = data;
av_log(s->avctx, AV_LOG_DEBUG, "Quantisation: %"PRIu16"\n", data);
break;
case ChannelNumber:
av_log(s->avctx, AV_LOG_DEBUG, "Channel number %"PRIu16"\n", data);
if (data >= *planes) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid channel number\n");
return AVERROR_INVALIDDATA;
}
s->channel_num = data;
init_plane_defaults(s);
break;
case 70:
av_log(s->avctx, AV_LOG_DEBUG,
"Subsampling or bit-depth flag? %"PRIu16"\n", data);
if (!(data == 10 || data == 12)) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid bits per channel\n");
return AVERROR_INVALIDDATA;
}
s->bpc = data;
break;
case 71:
s->codebook = data;
av_log(s->avctx, AV_LOG_DEBUG, "Codebook %i\n", s->codebook);
break;
case 72:
s->codebook = data;
av_log(s->avctx, AV_LOG_DEBUG, "Other codebook? %i\n", s->codebook);
break;
case 84:
av_log(s->avctx, AV_LOG_DEBUG, "Sample format? %"PRIu16"\n", data);
switch (data) {
case 1:
s->coded_format = AV_PIX_FMT_YUV422P10;
break;
case 3:
s->coded_format = AV_PIX_FMT_GBRP12;
break;
case 4:
s->coded_format = AV_PIX_FMT_GBRAP12;
break;
default:
avpriv_report_missing_feature(s->avctx, "Sample format %"PRIu16, data);
return AVERROR_PATCHWELCOME;
}
*planes = av_pix_fmt_count_planes(s->coded_format);
break;
case -85:
av_log(s->avctx, AV_LOG_DEBUG, "Cropped height %"PRIu16"\n", data);
s->cropped_height = data;
break;
case 101:
av_log(s->avctx, AV_LOG_DEBUG, "Bits per component: %"PRIu16"\n", data);
s->bpc = data;
break;
case PrescaleShift:
s->prescale_shift[0] = (data >> 0) & 0x7;
s->prescale_shift[1] = (data >> 3) & 0x7;
s->prescale_shift[2] = (data >> 6) & 0x7;
av_log(s->avctx, AV_LOG_DEBUG, "Prescale shift (VC-5): %"PRIX16"\n", data);
break;
default:
av_log(s->avctx, AV_LOG_DEBUG, "Unknown tag %"PRIu16" data %"PRIX16"\n",
tag, data);
}
return 0;
}
static int read_lowpass_coeffs(CFHDContext *s, GetByteContext *gb,
int16_t *coeff_data)
{
int i, j;
int lowpass_height = s->plane[s->channel_num].band[0][0].height;
int lowpass_width = s->plane[s->channel_num].band[0][0].width;
int lowpass_a_height = s->plane[s->channel_num].band[0][0].a_height;
int lowpass_a_width = s->plane[s->channel_num].band[0][0].a_width;
if (lowpass_height > lowpass_a_height ||
lowpass_width > lowpass_a_width ||
lowpass_a_width * lowpass_a_height * sizeof(*coeff_data) > bytestream2_get_bytes_left(gb)) {
av_log(s->avctx, AV_LOG_ERROR, "Too many lowpass coefficients\n");
return AVERROR_INVALIDDATA;
}
av_log(s->avctx, AV_LOG_DEBUG,
"Start of lowpass coeffs component %d height:%d, width:%d\n",
s->channel_num, lowpass_height, lowpass_width);
for (i = 0; i < lowpass_height; i++) {
for (j = 0; j < lowpass_width; j++)
coeff_data[j] = bytestream2_get_be16u(gb);
coeff_data += lowpass_width;
}
/* Align to mod-4 position to continue reading tags */
bytestream2_seek(gb, bytestream2_tell(gb) & 3, SEEK_CUR);
/* Copy last coefficient line if height is odd. */
if (lowpass_height & 1) {
int16_t *last_line = &coeff_data[lowpass_height * lowpass_width];
memcpy(last_line, &last_line[-lowpass_width],
lowpass_width * sizeof(*coeff_data));
}
av_log(s->avctx, AV_LOG_DEBUG, "Lowpass coefficients %i\n",
lowpass_width * lowpass_height);
return 0;
}
#define DECODE_SUBBAND_COEFFS(TABLE, COND) \
while (1) { \
int level, run, coeff; \
BITSTREAM_RL_VLC(level, run, &s->bc, s->TABLE, VLC_BITS, 3); \
\
/* escape */ \
if (COND) \
break; \
\
count += run; \
\
if (count > expected) { \
av_log(s->avctx, AV_LOG_ERROR, "Escape codeword not found, " \
"probably corrupt data\n"); \
return AVERROR_INVALIDDATA; \
} \
\
coeff = dequant_and_decompand(level, s->quantisation); \
for (i = 0; i < run; i++) \
*coeff_data++ = coeff; \
} \
static int read_highpass_coeffs(CFHDContext *s, GetByteContext *gb,
int16_t *coeff_data)
{
int i, ret;
int highpass_height = s->plane[s->channel_num].band[s->level][s->subband_num].height;
int highpass_width = s->plane[s->channel_num].band[s->level][s->subband_num].width;
int highpass_a_width = s->plane[s->channel_num].band[s->level][s->subband_num].a_width;
int highpass_a_height = s->plane[s->channel_num].band[s->level][s->subband_num].a_height;
ptrdiff_t highpass_stride = s->plane[s->channel_num].band[s->level][s->subband_num].stride;
int expected = highpass_height * highpass_stride;
int a_expected = highpass_a_height * highpass_a_width;
int count = 0;
unsigned bytes;
if (highpass_height > highpass_a_height ||
highpass_width > highpass_a_width ||
a_expected < expected) {
av_log(s->avctx, AV_LOG_ERROR, "Too many highpass coefficients\n");
return AVERROR_INVALIDDATA;
}
av_log(s->avctx, AV_LOG_DEBUG,
"Start subband coeffs plane %i level %i codebook %i expected %i\n",
s->channel_num, s->level, s->codebook, expected);
if ((ret = bitstream_init8(&s->bc, gb->buffer,
bytestream2_get_bytes_left(gb))) < 0)
return ret;
if (!s->codebook) {
DECODE_SUBBAND_COEFFS(table_9_rl_vlc, level == 64)
} else {
DECODE_SUBBAND_COEFFS(table_18_rl_vlc, level == 255 && run == 2)
}
bytes = FFALIGN(AV_CEIL_RSHIFT(bitstream_tell(&s->bc), 3), 4);
if (bytes > bytestream2_get_bytes_left(gb)) {
av_log(s->avctx, AV_LOG_ERROR, "Bitstream overread error\n");
return AVERROR_INVALIDDATA;
} else
bytestream2_seek(gb, bytes, SEEK_CUR);
av_log(s->avctx, AV_LOG_DEBUG, "End subband coeffs %i extra %i\n",
count, count - expected);
s->codebook = 0;
/* Copy last coefficient line if height is odd. */
if (highpass_height & 1) {
int16_t *last_line = &coeff_data[expected];
memcpy(last_line, &last_line[-highpass_stride],
highpass_stride * sizeof(*coeff_data));
}
return 0;
}
static int reconstruct_level(CFHDContext *s, AVFrame *pic, int plane, int level)
{
int i, j, idx = level - 1, idx2 = level > 1 ? 1 : 0;
int16_t *low, *high, *output, *dst;
int lowpass_height = s->plane[plane].band[idx][idx2].height;
int lowpass_width = s->plane[plane].band[idx][idx2].width;
ptrdiff_t highpass_stride = s->plane[plane].band[idx][1].stride;
if (lowpass_height > s->plane[plane].band[idx][idx2].a_height ||
lowpass_width > s->plane[plane].band[idx][idx2].a_width ||
s->plane[plane].band[idx][1].width > s->plane[plane].band[idx][1].a_width ||
!highpass_stride) {
av_log(s->avctx, AV_LOG_ERROR, "Invalid plane dimensions\n");
return AVERROR_INVALIDDATA;
}
av_log(s->avctx, AV_LOG_DEBUG, "Level %d plane %i %i %i %ti\n",
level, plane, lowpass_height, lowpass_width, highpass_stride);
low = s->plane[plane].subband[0];
high = s->plane[plane].subband[2 + 3 * idx];
output = s->plane[plane].l_h[3 * idx];
for (i = 0; i < lowpass_width; i++) {
vert_filter(output, lowpass_width, low, lowpass_width, high,
highpass_stride, lowpass_height);
low++;
high++;
output++;
}
low = s->plane[plane].subband[1 + 3 * idx];
high = s->plane[plane].subband[3 + 3 * idx];
output = s->plane[plane].l_h[1 + 3 * idx];
for (i = 0; i < lowpass_width; i++) {
// note the stride of "low" is highpass_stride
vert_filter(output, lowpass_width, low, highpass_stride, high,
highpass_stride, lowpass_height);
low++;
high++;
output++;
}
low = s->plane[plane].l_h[0 + 3 * idx];
high = s->plane[plane].l_h[1 + 3 * idx];
if (level != 3) {
output = s->plane[plane].subband[0];
for (i = 0; i < lowpass_height * 2; i++) {
horiz_filter(output, low, high, lowpass_width);
low += lowpass_width;
high += lowpass_width;
output += lowpass_width * 2;
}
if (s->bpc == 12 || level == 2) {
output = s->plane[plane].subband[0];
for (i = 0; i < lowpass_height * 2; i++) {
for (j = 0; j < lowpass_width * 2; j++)
output[j] <<= 2;
output += lowpass_width * 2;
}
}
} else {
int act_plane = plane == 1 ? 2 : plane == 2 ? 1 : plane;
dst = (int16_t *)pic->data[act_plane];
for (i = 0; i < lowpass_height * 2; i++) {
horiz_filter_clip(dst, low, high, lowpass_width, s->bpc);
low += lowpass_width;
high += lowpass_width;
dst += pic->linesize[act_plane] / 2;
}
}
return 0;
}
static int cfhd_decode(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
CFHDContext *s = avctx->priv_data;
GetByteContext gb;
ThreadFrame frame = { .f = data };
int ret = 0, planes, plane;
int16_t tag;
uint16_t value;
init_frame_defaults(s);
planes = av_pix_fmt_count_planes(s->coded_format);
bytestream2_init(&gb, avpkt->data, avpkt->size);
while (bytestream2_get_bytes_left(&gb) > 4) {
if ((ret = parse_tag(s, &gb, &tag, &value, &planes)) < 0)
return ret;
/* Some kind of end of header tag */
if (tag == 4 && value == 0x1A4A)
break;
}
if (s->coded_width <= 0 || s->coded_height <= 0 || s->coded_format == AV_PIX_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Video dimensions/format missing or invalid\n");
return AVERROR_INVALIDDATA;
}
ret = ff_set_dimensions(s->avctx, s->coded_width, s->coded_height);
if (ret < 0)
return ret;
if (s->cropped_height)
s->avctx->height = s->cropped_height;
s->avctx->pix_fmt = s->coded_format;
if (s->a_width != s->coded_width || s->a_height != s->coded_height ||
s->a_format != s->coded_format) {
free_buffers(s);
if ((ret = alloc_buffers(s)) < 0) {
free_buffers(s);
return ret;
}
}
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
return ret;
s->coded_width = 0;
s->coded_height = 0;
s->coded_format = AV_PIX_FMT_NONE;
while (bytestream2_get_bytes_left(&gb) > 4) {
int16_t *coeff_data;
if ((ret = parse_tag(s, &gb, &tag, &value, &planes)) < 0)
return ret;
coeff_data = s->plane[s->channel_num].subband[s->subband_num_actual];
if (tag == 4 && value == 0x0F0F) {
if ((ret = read_lowpass_coeffs(s, &gb, coeff_data)) < 0)
return ret;
} else if (tag == 55 && s->subband_num_actual != 255) {
if ((ret = read_highpass_coeffs(s, &gb, coeff_data)) < 0)
return ret;
}
}
if (s->coded_width || s->coded_height || s->coded_format != AV_PIX_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Invalid dimensions\n");
return AVERROR_INVALIDDATA;
}
planes = av_pix_fmt_count_planes(avctx->pix_fmt);
for (plane = 0; plane < planes; plane++) {
/* level 1 */
if ((ret = reconstruct_level(s, data, plane, 1)) < 0)
return ret;
/* level 2 */
if ((ret = reconstruct_level(s, data, plane, 2)) < 0)
return ret;
/* level 3 */
if ((ret = reconstruct_level(s, data, plane, 3)) < 0)
return ret;
}
*got_frame = 1;
return avpkt->size;
}
static av_cold int cfhd_close(AVCodecContext *avctx)
{
CFHDContext *s = avctx->priv_data;
free_buffers(s);
ff_free_vlc(&s->vlc_9);
ff_free_vlc(&s->vlc_18);
return 0;
}
AVCodec ff_cfhd_decoder = {
.name = "cfhd",
.long_name = NULL_IF_CONFIG_SMALL("Cineform HD"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_CFHD,
.priv_data_size = sizeof(CFHDContext),
.init = cfhd_init,
.init_thread_copy = ONLY_IF_THREADS_ENABLED(cfhd_init),
.close = cfhd_close,
.decode = cfhd_decode,
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
};

108
libavcodec/cfhd.h
Unescape View File

@ -0,0 +1,108 @@
/*
* Copyright (c) 2015 Kieran Kunhya
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVCODEC_CFHD_H
#define AVCODEC_CFHD_H
#include <stdint.h>
#include "avcodec.h"
#include "bitstream.h"
#define VLC_BITS 9
#define SUBBAND_COUNT 10
typedef struct CFHD_RL_VLC_ELEM {
int16_t level;
int8_t len;
uint16_t run;
} CFHD_RL_VLC_ELEM;
#define DWT_LEVELS 3
typedef struct SubBand {
int level;
int orientation;
ptrdiff_t stride;
int a_width;
int width;
int a_height;
int height;
int pshift;
int quant;
uint8_t *ibuf;
} SubBand;
typedef struct Plane {
int width;
int height;
ptrdiff_t stride;
int16_t *idwt_buf;
int16_t *idwt_tmp;
/* TODO: merge this into SubBand structure */
int16_t *subband[SUBBAND_COUNT];
int16_t *l_h[8];
SubBand band[DWT_LEVELS][4];
} Plane;
typedef struct CFHDContext {
AVCodecContext *avctx;
CFHD_RL_VLC_ELEM table_9_rl_vlc[2088];
VLC vlc_9;
CFHD_RL_VLC_ELEM table_18_rl_vlc[4572];
VLC vlc_18;
BitstreamContext bc;
int coded_width;
int coded_height;
int cropped_height;
enum AVPixelFormat coded_format;
int a_width;
int a_height;
int a_format;
int bpc; // bits per channel/component
int channel_cnt;
int subband_cnt;
int channel_num;
uint8_t lowpass_precision;
uint16_t quantisation;
int wavelet_depth;
int pshift;
int codebook;
int subband_num;
int level;
int subband_num_actual;
uint8_t prescale_shift[3];
Plane plane[4];
} CFHDContext;
int ff_cfhd_init_vlcs(CFHDContext *s);
#endif /* AVCODEC_CFHD_H */

337
libavcodec/cfhddata.c
Unescape View File

@ -0,0 +1,337 @@
/*
* Copyright (c) 2015 Kieran Kunhya
*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdint.h>
#include "libavutil/attributes.h"
#include "cfhd.h"
#define NB_VLC_TABLE_9 (71 + 3)
#define NB_VLC_TABLE_18 (263 + 1)
static const uint32_t table_9_vlc_bits[NB_VLC_TABLE_9] = {
0, 0x2, 0xc, 0x1a,
0x1d, 0x1e, 0x39, 0x3e,
0x37, 0x7e, 0x6c, 0xe2,
0xfe, 0xdb, 0xe0, 0x1c3,
0x1c6, 0x1ff, 0x1fe, 0x1b5,
0x369, 0x385, 0x71d, 0x6d0,
0x708, 0x71f, 0xe3d, 0xe39,
0xe13, 0xe12, 0x1c71, 0x1b45,
0x1b47, 0x3689, 0x38f2, 0x38e1,
0x38e0, 0x38f1, 0x3688, 0x6d1b,
0x71e0, 0x6d19, 0x71e7, 0xe3cd,
0xda35, 0xda30, 0xe3c3, 0x1b469,
0x1b462, 0x1c798, 0x1b463, 0x1c799,
0x38f08, 0x38f09, 0x38f0a, 0x6d1a0,
0x6d1a3, 0x6d1a1, 0xda345, 0xda344,
0xe3c2d, 0xe3c2f, 0xe3c2e, 0x38f0b2,
0x71e160, 0x71e162, 0x71e166, 0x71e161,
0xe3c2ce, 0xe3c2c6, 0xe3c2c7, 0x1C7859E,
0x38F0B3F, 0x38F0B3E,
};
static const uint8_t table_9_vlc_len[NB_VLC_TABLE_9] = {
1, 2, 4, 5, 5, 5, 6, 6,
6, 7, 7, 8, 8, 8, 8, 9,
9, 9, 9, 9, 10, 10, 11, 11,
11, 11, 12, 12, 12, 12, 13, 13,
13, 14, 14, 14, 14, 14, 14, 15,
15, 15, 15, 16, 16, 16, 16, 17,
17, 17, 17, 17, 18, 18, 18, 19,
19, 19, 20, 20, 20, 20, 20, 22,
23, 23, 23, 23, 24, 24, 24, 25,
26, 26,
};
static const uint16_t table_9_vlc_run[NB_VLC_TABLE_9] = {
1, 1, 1, 1, 12, 1, 32, 160,
1, 1, 1, 320, 1, 1, 80, 120,
1, 1, 100, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1
};
static const uint8_t table_9_vlc_level[NB_VLC_TABLE_9] = {
0, 1, 2, 3, 0, 4, 0, 0,
5, 7, 6, 0, 9, 8, 0, 0,
11, 12, 0, 10, 13, 14, 17, 15,
16, 18, 22, 21, 20, 19, 25, 23,
24, 27, 31, 29, 28, 30, 26, 33,
34, 32, 35, 39, 37, 36, 38, 42,
40, 43, 41, 44, 45, 46, 47, 48,
50, 49, 52, 51, 53, 55, 54, 56,
57, 59, 60, 58, 61, 62, 63, 64,
64, 64,
};
static const uint32_t table_18_vlc_bits[NB_VLC_TABLE_18] = {
0, 0x2, 0x7, 0x19,
0x30, 0x36, 0x6f, 0x63,
0x69, 0x6b, 0xd1, 0xd4,
0xdc, 0x189, 0x18a, 0x1a0,
0x1ab, 0x377, 0x310, 0x316,
0x343, 0x354, 0x375, 0x623,
0x684, 0x685, 0x6ab, 0x6ec,
0xddb, 0xc5c, 0xc5e, 0xc44,
0xd55, 0xdd1, 0xdd3, 0x1bb5,
0x188b, 0x18bb, 0x18bf, 0x1aa8,
0x1ba0, 0x1ba5, 0x1ba4, 0x3115,
0x3175, 0x317d, 0x3553, 0x3768,
0x6e87, 0x6ed3, 0x62e8, 0x62f8,
0x6228, 0x6aa4, 0x6e85, 0xc453,
0xc5d3, 0xc5f3, 0xdda4, 0xdd08,
0xdd0c, 0x1bb4b, 0x1bb4a, 0x18ba5,
0x18be5, 0x1aa95, 0x1aa97, 0x188a4,
0x1ba13, 0x31748, 0x317c8, 0x35528,
0x3552c, 0x37424, 0x37434, 0x37436,
0x62294, 0x62e92, 0x62f92, 0x6aa52,
0x6aa5a, 0x6e86a, 0x6e86e, 0x6e84a,
0xc452a, 0xc5d27, 0xc5f26, 0xd54a6,
0xd54b6, 0xdd096, 0xdd0d6, 0xdd0de,
0x188a56, 0x18ba4d, 0x18be4e, 0x18be4f,
0x1aa96e, 0x1ba12e, 0x1ba12f, 0x1ba1af,
0x1ba1bf, 0x37435d, 0x37437d, 0x317498,
0x35529c, 0x35529d, 0x3552de, 0x3552df,
0x62e933, 0x62295d, 0x6aa53d, 0x6aa53f,
0x6aa53e, 0x6e86b9, 0x6e86f8, 0xd54a79,
0xc5d265, 0xc452b8, 0xdd0d71, 0xd54a78,
0xdd0d70, 0xdd0df2, 0xdd0df3, 0x188a5f6,
0x188a5f5, 0x188a5f4, 0x188a5f3, 0x188a5f2,
0x188a5f1, 0x188a5f0, 0x188a5ef, 0x188a5ee,
0x188a5ed, 0x188a5aa, 0x188a5e3, 0x188a5df,
0x188a589, 0x188a5dd, 0x188a578, 0x188a5e0,
0x188a588, 0x188a5d6, 0x188a5db, 0x188a5e1,
0x188a587, 0x188a59a, 0x188a5c4, 0x188a5ec,
0x188a586, 0x188a573, 0x188a59c, 0x188a5c8,
0x188a5fb, 0x188a5a1, 0x188a5eb, 0x188a5a8,
0x188a584, 0x188a5d2, 0x188a599, 0x188a598,
0x188a583, 0x18ba4c9, 0x188a5d0, 0x188a594,
0x188a582, 0x188a5cb, 0x188a5d8, 0x188a5e7,
0x188a581, 0x188a5ea, 0x188a5a9, 0x188a5a6,
0x188a580, 0x188a5a0, 0x188a59d, 0x188a5c3,
0x188a57f, 0x188a5c0, 0x188a5de, 0x188a5d4,
0x188a57e, 0x188a5c2, 0x188a592, 0x188a5cd,
0x188a57d, 0x188a5a3, 0x188a5e8, 0x188a5a2,
0x188a57c, 0x188a58e, 0x188a5b3, 0x188a5b2,
0x188a5b1, 0x188a5b0, 0x188a5af, 0x188a5ae,
0x188a5ad, 0x188a5ac, 0x188a5ab, 0x188a5da,
0x188a5e4, 0x188a5e5, 0x188a5d9, 0x188a5b5,
0x188a5bc, 0x188a5bd, 0x188a5e9, 0x188a5cc,
0x188a585, 0x188a5d3, 0x188a5e2, 0x188a595,
0x188a596, 0x188a5b8, 0x188a590, 0x188a5c9,
0x188a5a4, 0x188a5e6, 0x188a5a5, 0x188a5ce,
0x188a5bf, 0x188a572, 0x188a59b, 0x188a5be,
0x188a5c7, 0x188a5ca, 0x188a5d5, 0x188a57b,
0x188a58d, 0x188a58c, 0x188a58b, 0x188a58a,
0x18ba4c8, 0x188a5c5, 0x188a5fa, 0x188a5bb,
0x188a5c1, 0x188a5cf, 0x188a5b9, 0x188a5b6,
0x188a597, 0x188a5fe, 0x188a5d7, 0x188a5ba,
0x188a591, 0x188a5c6, 0x188a5dc, 0x188a57a,
0x188a59f, 0x188a5f9, 0x188a5b4, 0x188a5a7,
0x188a58f, 0x188a5fd, 0x188a5b7, 0x188a593,
0x188a59e, 0x188a5f8, 0x188a5ff, 0x188a5fc,
0x188a579, 0x188a5f7, 0x3114ba2, 0x3114ba3,
};
static const uint8_t table_18_vlc_len[NB_VLC_TABLE_18] = {
1, 2, 3, 5, 6, 6, 7, 7,
7, 7, 8, 8, 8, 9, 9, 9,
9, 10, 10, 10, 10, 10, 10, 11,
11, 11, 11, 11, 12, 12, 12, 12,
12, 12, 12, 13, 13, 13, 13, 13,
13, 13, 13, 14, 14, 14, 14, 14,
15, 15, 15, 15, 15, 15, 15, 16,
16, 16, 16, 16, 16, 17, 17, 17,
17, 17, 17, 17, 17, 18, 18, 18,
18, 18, 18, 18, 19, 19, 19, 19,
19, 19, 19, 19, 20, 20, 20, 20,
20, 20, 20, 20, 21, 21, 21, 21,
21, 21, 21, 21, 21, 22, 22, 22,
22, 22, 22, 22, 23, 23, 23, 23,
23, 23, 23, 24, 24, 24, 24, 24,
24, 24, 24, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 26, 26,
};
static const uint16_t table_18_vlc_run[NB_VLC_TABLE_18] = {
1, 1, 1, 1, 1, 1, 1, 1,
12, 1, 20, 1, 1, 1, 32, 1,
1, 1, 1, 1, 60, 1, 1, 1,
1, 100, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 180, 1,
1, 320, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 2,
};
static const uint8_t table_18_vlc_level[NB_VLC_TABLE_18] = {
0, 1, 2, 3, 4, 5, 8, 6,
0, 7, 0, 9, 10, 11, 0, 12,
13, 18, 14, 15, 0, 16, 17, 19,
20, 0, 21, 22, 29, 24, 25, 23,
26, 27, 28, 35, 30, 31, 0, 32,
33, 0, 34, 36, 37, 38, 39, 40,
46, 47, 42, 43, 41, 44, 45, 48,
49, 50, 53, 51, 52, 61, 60, 55,
56, 57, 58, 54, 59, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72,
73, 75, 76, 74, 77, 78, 79, 80,
81, 82, 83, 84, 85, 86, 87, 88,
89, 90, 91, 92, 93, 99, 100, 94,
95, 96, 97, 98, 102, 101, 103, 105,
104, 106, 107, 111, 109, 108, 113, 110,
112, 114, 115, 225, 189, 188, 203, 202,
197, 207, 169, 223, 159, 235, 152, 192,
179, 201, 172, 149, 178, 120, 219, 150,
127, 211, 125, 158, 247, 238, 163, 228,
183, 217, 168, 122, 128, 249, 187, 186,
136, 181, 255, 230, 135, 233, 222, 145,
134, 167, 248, 209, 243, 216, 164, 140,
157, 239, 191, 251, 156, 139, 242, 133,
162, 213, 165, 212, 227, 198, 236, 234,
117, 215, 124, 123, 254, 253, 148, 218,
146, 147, 224, 143, 184, 185, 166, 132,
129, 250, 151, 119, 193, 176, 245, 229,
206, 144, 208, 137, 241, 237, 190, 240,
131, 232, 252, 171, 205, 204, 118, 214,
180, 126, 182, 175, 141, 138, 177, 153,
194, 160, 121, 174, 246, 130, 200, 170,
221, 196, 142, 210, 199, 155, 154, 244,
220, 195, 161, 231, 173, 226, 116, 255,
};
static int init_vlc_signed(VLC *vlc, CFHD_RL_VLC_ELEM table_rl_vlc[],
unsigned bound,
const uint32_t table_vlc_bits[],
const uint8_t table_vlc_len[],
const uint16_t table_vlc_run[],
const uint8_t table_vlc_level[])
{
uint32_t vlc_bits[NB_VLC_TABLE_18 * 2];
uint8_t vlc_len[NB_VLC_TABLE_18 * 2];
uint16_t vlc_run[NB_VLC_TABLE_18 * 2];
int16_t vlc_level[NB_VLC_TABLE_18 * 2];
unsigned i, j;
int ret;
for (i = 0, j = 0; i < bound; i++, j++) {
vlc_bits[j] = table_vlc_bits[i];
vlc_len[j] = table_vlc_len[i];
vlc_run[j] = table_vlc_run[i];
vlc_level[j] = table_vlc_level[i];
/* Don't include the zero level nor escape bits */
if (table_vlc_level[i] &&
vlc_bits[j] != table_vlc_bits[bound - 1]) {
vlc_bits[j] <<= 1;
vlc_len[j]++;
j++;
vlc_bits[j] = (table_vlc_bits[i] << 1) | 1;
vlc_len[j] = table_vlc_len[i] + 1;
vlc_run[j] = table_vlc_run[i];
vlc_level[j] = -table_vlc_level[i];
}
}
if ((ret = init_vlc(vlc, VLC_BITS, j, vlc_len, 1, 1, vlc_bits, 4, 4, 0)) < 0)
return ret;
for (i = 0; i < (*vlc).table_size; i++) {
int code = (*vlc).table[i][0];
int len = (*vlc).table[i][1];
int level, run;
if (len < 0) { // more bits needed
run = 0;
level = code;
} else {
run = vlc_run[code];
level = vlc_level[code];
}
table_rl_vlc[i].len = len;
table_rl_vlc[i].level = level;
table_rl_vlc[i].run = run;
}
return 0;
}
av_cold int ff_cfhd_init_vlcs(CFHDContext *s)
{
/** Similar to dv.c, generate signed VLC tables **/
int ret = init_vlc_signed(&s->vlc_9, s->table_9_rl_vlc, NB_VLC_TABLE_9,
table_9_vlc_bits, table_9_vlc_len,
table_9_vlc_run, table_9_vlc_level);
if (ret < 0)
return ret;
return init_vlc_signed(&s->vlc_18, s->table_18_rl_vlc, NB_VLC_TABLE_18,
table_18_vlc_bits, table_18_vlc_len,
table_18_vlc_run, table_18_vlc_level);
}

7
libavcodec/codec_desc.c
Unescape View File

@ -1428,6 +1428,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
.long_name = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
.props = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
},
{
.id = AV_CODEC_ID_CFHD,
.type = AVMEDIA_TYPE_VIDEO,
.name = "cfhd",
.long_name = NULL_IF_CONFIG_SMALL("Cineform HD"),
.props = AV_CODEC_PROP_LOSSY,
},
/* various PCM "codecs" */
{

2
libavcodec/version.h
Unescape View File

@ -28,7 +28,7 @@
#include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 57
#define LIBAVCODEC_VERSION_MINOR 35
#define LIBAVCODEC_VERSION_MINOR 36
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

1
libavformat/riff.c
Unescape View File

@ -368,6 +368,7 @@ const AVCodecTag ff_codec_bmp_tags[] = {
{ AV_CODEC_ID_RSCC, MKTAG('I', 'S', 'C', 'C') },
{ AV_CODEC_ID_MAGICYUV, MKTAG('M', 'A', 'G', 'Y') },
{ AV_CODEC_ID_AV1, MKTAG('A', 'V', '0', '1') },
{ AV_CODEC_ID_CFHD, MKTAG('C', 'F', 'H', 'D') },
{ AV_CODEC_ID_NONE, 0 }
};

Write Preview
Loading…
Cancel
Save