FFmpeg: libavcodec/vble.c Source File

FFmpeg

[フレーム]

libavcodec

vble.c

Go to the documentation of this file.

1 /*

2 * VBLE Decoder

4 *

5 * This file is part of FFmpeg.

6 *

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

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * VBLE Decoder

25 */

27 #include "libavutil/imgutils.h"

29 #define BITSTREAM_READER_LE

30 #include "avcodec.h"

31 #include "codec_internal.h"

32 #include "get_bits.h"

33 #include "lossless_videodsp.h"

34 #include "mathops.h"

35 #include "thread.h"

37 typedef struct VBLEContext {

38 AVCodecContext *avctx;

39 LLVidDSPContext llviddsp;

41 int size;

42 uint8_t *val; ///< This array first holds the lengths of vlc symbols and then their value.

43 } VBLEContext;

45 static int vble_unpack(VBLEContext *ctx, GetBitContext *gb)

46 {

47 int i;

48 int allbits = 0;

49 static const uint8_t LUT[256] = {

50 8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

51 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

52 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

53 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

54 7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

55 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

56 6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

57 5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,

58 };

60 /* Read all the lengths in first */

61 for (i = 0; i < ctx->size; i++) {

62 /* At most we need to read 9 bits total to get indices up to 8 */

63 int val = show_bits(gb, 8);

65 // read reverse unary

66 if (val) {

67 val = LUT[val];

68 skip_bits(gb, val + 1);

69 ctx->val[i] = val;

70 } else {

71 skip_bits(gb, 8);

72 if (!get_bits1(gb))

73 return -1;

74 ctx->val[i] = 8;

75 }

76 allbits += ctx->val[i];

77 }

79 /* Check we have enough bits left */

80 if (get_bits_left(gb) < allbits)

81 return -1;

82 return 0;

83 }

85 static void vble_restore_plane(VBLEContext *ctx, AVFrame *pic,

86 GetBitContext *gb, int plane,

87 int offset, int width, int height)

88 {

89 uint8_t *dst = pic->data[plane];

90 uint8_t *val = ctx->val + offset;

91 int stride = pic->linesize[plane];

92 int i, j, left, left_top;

94 for (i = 0; i < height; i++) {

95 for (j = 0; j < width; j++) {

96 /* get_bits can't take a length of 0 */

97 if (val[j]) {

98 int v = (1 << val[j]) + get_bits(gb, val[j]) - 1;

99 val[j] = (v >> 1) ^ -(v & 1);

100 }

101 }

102 if (i) {

103 left = 0;

104 left_top = dst[-stride];

105 ctx->llviddsp.add_median_pred(dst, dst - stride, val,

106 width, &left, &left_top);

107 } else {

108 dst[0] = val[0];

109 for (j = 1; j < width; j++)

110 dst[j] = val[j] + dst[j - 1];

111 }

112 dst += stride;

113 val += width;

114 }

115 }

116

117 static int vble_decode_frame(AVCodecContext *avctx, AVFrame *pic,

118 int *got_frame, AVPacket *avpkt)

119 {

120 VBLEContext *ctx = avctx->priv_data;

121 GetBitContext gb;

122 const uint8_t *src = avpkt->data;

123 int version;

124 int offset = 0;

125 int width_uv = avctx->width / 2, height_uv = avctx->height / 2;

126 int ret;

127

128 if (avpkt->size < 4 || avpkt->size - 4 > INT_MAX/8) {

129 av_log(avctx, AV_LOG_ERROR, "Invalid packet size\n");

130 return AVERROR_INVALIDDATA;

131 }

132

133 /* Allocate buffer */

134 if ((ret = ff_thread_get_buffer(avctx, pic, 0)) < 0)

135 return ret;

136

137 /* Set flags */

138 pic->key_frame = 1;

139 pic->pict_type = AV_PICTURE_TYPE_I;

140

141 /* Version should always be 1 */

142 version = AV_RL32(src);

143

144 if (version != 1)

145 av_log(avctx, AV_LOG_WARNING, "Unsupported VBLE Version: %d\n", version);

146

147 init_get_bits(&gb, src + 4, (avpkt->size - 4) * 8);

148

149 /* Unpack */

150 if (vble_unpack(ctx, &gb) < 0) {

151 av_log(avctx, AV_LOG_ERROR, "Invalid Code\n");

152 return AVERROR_INVALIDDATA;

153 }

154

155 /* Restore planes. Should be almost identical to Huffyuv's. */

156 vble_restore_plane(ctx, pic, &gb, 0, offset, avctx->width, avctx->height);

157

158 /* Chroma */

159 if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {

160 offset += avctx->width * avctx->height;

161 vble_restore_plane(ctx, pic, &gb, 1, offset, width_uv, height_uv);

162

163 offset += width_uv * height_uv;

164 vble_restore_plane(ctx, pic, &gb, 2, offset, width_uv, height_uv);

165 }

166

167 *got_frame = 1;

168

169 return avpkt->size;

170 }

171

172 static av_cold int vble_decode_close(AVCodecContext *avctx)

173 {

174 VBLEContext *ctx = avctx->priv_data;

175 av_freep(&ctx->val);

176

177 return 0;

178 }

179

180 static av_cold int vble_decode_init(AVCodecContext *avctx)

181 {

182 VBLEContext *ctx = avctx->priv_data;

183

184 /* Stash for later use */

185 ctx->avctx = avctx;

186 ff_llviddsp_init(&ctx->llviddsp);

187

188 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

189 avctx->bits_per_raw_sample = 8;

190

191 ctx->size = av_image_get_buffer_size(avctx->pix_fmt,

192 avctx->width, avctx->height, 1);

193

194 ctx->val = av_malloc_array(ctx->size, sizeof(*ctx->val));

195

196 if (!ctx->val) {

197 av_log(avctx, AV_LOG_ERROR, "Could not allocate values buffer.\n");

198 return AVERROR(ENOMEM);

199 }

200

201 return 0;

202 }

203

204 const FFCodec ff_vble_decoder = {

205 .p.name = "vble",

206 .p.long_name = NULL_IF_CONFIG_SMALL("VBLE Lossless Codec"),

207 .p.type = AVMEDIA_TYPE_VIDEO,

208 .p.id = AV_CODEC_ID_VBLE,

209 .priv_data_size = sizeof(VBLEContext),

210 .init = vble_decode_init,

211 .close = vble_decode_close,

212 FF_CODEC_DECODE_CB(vble_decode_frame),

213 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

214 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

215 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:839

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

vble_decode_close

static av_cold int vble_decode_close(AVCodecContext *avctx)

Definition: vble.c:172

VBLEContext::llviddsp

LLVidDSPContext llviddsp

Definition: vble.c:39

vble_decode_init

static av_cold int vble_decode_init(AVCodecContext *avctx)

Definition: vble.c:180

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:325

AVPacket::data

uint8_t * data

Definition: packet.h:374

FFCodec

Definition: codec_internal.h:112

VBLEContext

Definition: vble.c:37

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:649

thread.h

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:346

init

static int init

Definition: av_tx.c:47

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:467

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:379

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

GetBitContext

Definition: get_bits.h:61

ff_thread_get_buffer

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere

vble_restore_plane

static void vble_restore_plane(VBLEContext *ctx, AVFrame *pic, GetBitContext *gb, int plane, int offset, int width, int height)

Definition: vble.c:85

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:417

val

static double val(void *priv, double ch)

Definition: aeval.c:77

LLVidDSPContext

Definition: lossless_videodsp.h:28

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

width

#define width

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

AVFormatContext::flags

int flags

Flags modifying the (de)muxer behaviour.

Definition: avformat.h:1331

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1448

ctx

AVFormatContext * ctx

Definition: movenc.c:48

get_bits.h

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:113

VBLEContext::size

int size

Definition: vble.c:41

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

mathops.h

VBLEContext::avctx

AVCodecContext * avctx

Definition: vble.c:38

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:422

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:249

AVPacket::size

int size

Definition: packet.h:375

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

LUT

Definition: vf_morpho.c:63

codec_internal.h

VBLEContext::val

uint8_t * val

This array first holds the lengths of vlc symbols and then their value.

Definition: vble.c:42

height

#define height

av_image_get_buffer_size

int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)

Return the size in bytes of the amount of data required to store an image with the given parameters.

Definition: imgutils.c:466

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

version

Definition: libkvazaar.c:313

vble_decode_frame

static int vble_decode_frame(AVCodecContext *avctx, AVFrame *pic, int *got_frame, AVPacket *avpkt)

Definition: vble.c:117

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

show_bits

static unsigned int show_bits(GetBitContext *s, int n)

Show 1-25 bits.

Definition: get_bits.h:446

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: codec_internal.h:31

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

AVCodecContext::height

int height

Definition: avcodec.h:562

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:599

avcodec.h

stride

#define stride

Definition: h264pred_template.c:537

ret

Definition: filter_design.txt:187

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

ff_llviddsp_init

void ff_llviddsp_init(LLVidDSPContext *c)

Definition: lossless_videodsp.c:113

AVCodecContext

main external API structure.

Definition: avcodec.h:389

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO