FFmpeg  4.4.5
asvdec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2003 Michael Niedermayer
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  * ASUS V1/V2 decoder.
24  */
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/thread.h"
29 
30 #include "asv.h"
31 #include "avcodec.h"
32 #include "blockdsp.h"
33 #include "idctdsp.h"
34 #include "internal.h"
35 #include "mpeg12data.h"
36 
37 #define CCP_VLC_BITS 5
38 #define DC_CCP_VLC_BITS 4
39 #define AC_CCP_VLC_BITS 6
40 #define ASV1_LEVEL_VLC_BITS 4
41 #define ASV2_LEVEL_VLC_BITS 10
42 
43 static VLC ccp_vlc;
44 static VLC level_vlc;
45 static VLC dc_ccp_vlc;
46 static VLC ac_ccp_vlc;
48 
49 static av_cold void init_vlcs(void)
50 {
52  &ff_asv_ccp_tab[0][1], 2, 1,
53  &ff_asv_ccp_tab[0][0], 2, 1, 32);
55  &ff_asv_dc_ccp_tab[0][1], 2, 1,
56  &ff_asv_dc_ccp_tab[0][0], 2, 1, 16);
58  &ff_asv_ac_ccp_tab[0][1], 2, 1,
59  &ff_asv_ac_ccp_tab[0][0], 2, 1, 64);
61  &ff_asv_level_tab[0][1], 2, 1,
62  &ff_asv_level_tab[0][0], 2, 1, 16);
64  &ff_asv2_level_tab[0][1], 4, 2,
65  &ff_asv2_level_tab[0][0], 4, 2, 1024);
66 }
67 
68 static inline int asv1_get_level(GetBitContext *gb)
69 {
71 
72  if (code == 3)
73  return get_sbits(gb, 8);
74  else
75  return code - 3;
76 }
77 
78 // get_vlc2() is big-endian in this file
79 static inline int asv2_get_vlc2(GetBitContext *gb, VLC_TYPE (*table)[2], int bits)
80 {
81  unsigned int index;
82  int code, n;
83 
84  OPEN_READER(re, gb);
85  UPDATE_CACHE_LE(re, gb);
86 
87  index = SHOW_UBITS_LE(re, gb, bits);
88  code = table[index][0];
89  n = table[index][1];
90  LAST_SKIP_BITS(re, gb, n);
91 
92  CLOSE_READER(re, gb);
93 
94  return code;
95 }
96 
97 static inline int asv2_get_level(GetBitContext *gb)
98 {
100 
101  if (code == 31)
102  return (int8_t) get_bits_le(gb, 8);
103  else
104  return code - 31;
105 }
106 
107 static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
108 {
109  int i;
110 
111  block[0] = 8 * get_bits(&a->gb, 8);
112 
113  for (i = 0; i < 11; i++) {
114  const int ccp = get_vlc2(&a->gb, ccp_vlc.table, CCP_VLC_BITS, 1);
115 
116  if (ccp) {
117  if (ccp == 16)
118  break;
119  if (ccp < 0 || i >= 10) {
120  av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");
121  return AVERROR_INVALIDDATA;
122  }
123 
124  if (ccp & 8)
125  block[a->scantable.permutated[4 * i + 0]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
126  if (ccp & 4)
127  block[a->scantable.permutated[4 * i + 1]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
128  if (ccp & 2)
129  block[a->scantable.permutated[4 * i + 2]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
130  if (ccp & 1)
131  block[a->scantable.permutated[4 * i + 3]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
132  }
133  }
134 
135  return 0;
136 }
137 
138 static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
139 {
140  int i, count, ccp;
141 
142  count = get_bits_le(&a->gb, 4);
143 
144  block[0] = 8 * get_bits_le(&a->gb, 8);
145 
147  if (ccp) {
148  if (ccp & 4)
149  block[a->scantable.permutated[1]] = (asv2_get_level(&a->gb) * a->intra_matrix[1]) >> 4;
150  if (ccp & 2)
151  block[a->scantable.permutated[2]] = (asv2_get_level(&a->gb) * a->intra_matrix[2]) >> 4;
152  if (ccp & 1)
153  block[a->scantable.permutated[3]] = (asv2_get_level(&a->gb) * a->intra_matrix[3]) >> 4;
154  }
155 
156  for (i = 1; i < count + 1; i++) {
157  const int ccp = asv2_get_vlc2(&a->gb, ac_ccp_vlc.table, AC_CCP_VLC_BITS);
158 
159  if (ccp) {
160  if (ccp & 8)
161  block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
162  if (ccp & 4)
163  block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
164  if (ccp & 2)
165  block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
166  if (ccp & 1)
167  block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
168  }
169  }
170 
171  return 0;
172 }
173 
174 static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
175 {
176  int i, ret;
177 
178  a->bdsp.clear_blocks(block[0]);
179 
180  if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
181  for (i = 0; i < 6; i++) {
182  if ((ret = asv1_decode_block(a, block[i])) < 0)
183  return ret;
184  }
185  } else {
186  for (i = 0; i < 6; i++) {
187  if ((ret = asv2_decode_block(a, block[i])) < 0)
188  return ret;
189  }
190  }
191  return 0;
192 }
193 
194 static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
195 {
196  int16_t(*block)[64] = a->block;
197  int linesize = frame->linesize[0];
198 
199  uint8_t *dest_y = frame->data[0] + (mb_y * 16 * linesize) + mb_x * 16;
200  uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;
201  uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;
202 
203  a->idsp.idct_put(dest_y, linesize, block[0]);
204  a->idsp.idct_put(dest_y + 8, linesize, block[1]);
205  a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]);
206  a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
207 
208  if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
209  a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
210  a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
211  }
212 }
213 
214 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
215  AVPacket *avpkt)
216 {
217  ASV1Context *const a = avctx->priv_data;
218  const uint8_t *buf = avpkt->data;
219  int buf_size = avpkt->size;
220  AVFrame *const p = data;
221  int mb_x, mb_y, ret;
222 
223  if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)
224  return AVERROR_INVALIDDATA;
225 
226  if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
227  return ret;
229  p->key_frame = 1;
230 
231  if (avctx->codec_id == AV_CODEC_ID_ASV1) {
232  av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size,
233  buf_size);
234  if (!a->bitstream_buffer)
235  return AVERROR(ENOMEM);
236 
237  a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
238  (const uint32_t *) buf, buf_size / 4);
239  ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size);
240  } else {
241  ret = init_get_bits8_le(&a->gb, buf, buf_size);
242  }
243  if (ret < 0)
244  return ret;
245 
246  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
247  for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
248  if ((ret = decode_mb(a, a->block)) < 0)
249  return ret;
250 
251  idct_put(a, p, mb_x, mb_y);
252  }
253  }
254 
255  if (a->mb_width2 != a->mb_width) {
256  mb_x = a->mb_width2;
257  for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
258  if ((ret = decode_mb(a, a->block)) < 0)
259  return ret;
260 
261  idct_put(a, p, mb_x, mb_y);
262  }
263  }
264 
265  if (a->mb_height2 != a->mb_height) {
266  mb_y = a->mb_height2;
267  for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
268  if ((ret = decode_mb(a, a->block)) < 0)
269  return ret;
270 
271  idct_put(a, p, mb_x, mb_y);
272  }
273  }
274 
275  *got_frame = 1;
276 
277  emms_c();
278 
279  return (get_bits_count(&a->gb) + 31) / 32 * 4;
280 }
281 
283 {
284  static AVOnce init_static_once = AV_ONCE_INIT;
285  ASV1Context *const a = avctx->priv_data;
286  const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
287  int i;
288 
289  if (avctx->extradata_size < 1) {
290  av_log(avctx, AV_LOG_WARNING, "No extradata provided\n");
291  }
292 
293  ff_asv_common_init(avctx);
294  ff_blockdsp_init(&a->bdsp, avctx);
295  ff_idctdsp_init(&a->idsp, avctx);
296  ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
297  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
298 
299  if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) {
300  av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
301  if (avctx->codec_id == AV_CODEC_ID_ASV1)
302  a->inv_qscale = 6;
303  else
304  a->inv_qscale = 10;
305  }
306 
307  for (i = 0; i < 64; i++) {
308  int index = ff_asv_scantab[i];
309 
310  a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
311  a->inv_qscale;
312  }
313 
314  ff_thread_once(&init_static_once, init_vlcs);
315 
316  return 0;
317 }
318 
320 {
321  ASV1Context *const a = avctx->priv_data;
322 
323  av_freep(&a->bitstream_buffer);
324  a->bitstream_buffer_size = 0;
325 
326  return 0;
327 }
328 
329 #if CONFIG_ASV1_DECODER
331  .name = "asv1",
332  .long_name = NULL_IF_CONFIG_SMALL("ASUS V1"),
333  .type = AVMEDIA_TYPE_VIDEO,
334  .id = AV_CODEC_ID_ASV1,
335  .priv_data_size = sizeof(ASV1Context),
336  .init = decode_init,
337  .close = decode_end,
338  .decode = decode_frame,
339  .capabilities = AV_CODEC_CAP_DR1,
340  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
341 };
342 #endif
343 
344 #if CONFIG_ASV2_DECODER
346  .name = "asv2",
347  .long_name = NULL_IF_CONFIG_SMALL("ASUS V2"),
348  .type = AVMEDIA_TYPE_VIDEO,
349  .id = AV_CODEC_ID_ASV2,
350  .priv_data_size = sizeof(ASV1Context),
351  .init = decode_init,
352  .decode = decode_frame,
353  .capabilities = AV_CODEC_CAP_DR1,
354  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
355 };
356 #endif
AVCodec ff_asv1_decoder
AVCodec ff_asv2_decoder
const uint8_t ff_asv_level_tab[7][2]
Definition: asv.c:51
const uint8_t ff_asv_dc_ccp_tab[8][2]
Definition: asv.c:55
const uint8_t ff_asv_scantab[64]
Definition: asv.c:32
const uint8_t ff_asv_ac_ccp_tab[16][2]
Definition: asv.c:60
const uint16_t ff_asv2_level_tab[63][2]
Definition: asv.c:67
av_cold void ff_asv_common_init(AVCodecContext *avctx)
Definition: asv.c:89
const uint8_t ff_asv_ccp_tab[17][2]
Definition: asv.c:43
ASUS V1/V2 encoder/decoder common data.
#define AC_CCP_VLC_BITS
Definition: asvdec.c:39
static int asv1_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:107
static int asv1_get_level(GetBitContext *gb)
Definition: asvdec.c:68
#define CCP_VLC_BITS
Definition: asvdec.c:37
static VLC level_vlc
Definition: asvdec.c:44
static av_cold int decode_init(AVCodecContext *avctx)
Definition: asvdec.c:282
static int asv2_get_level(GetBitContext *gb)
Definition: asvdec.c:97
static int decode_mb(ASV1Context *a, int16_t block[6][64])
Definition: asvdec.c:174
static VLC ccp_vlc
Definition: asvdec.c:43
static av_cold int decode_end(AVCodecContext *avctx)
Definition: asvdec.c:319
static VLC ac_ccp_vlc
Definition: asvdec.c:46
#define ASV1_LEVEL_VLC_BITS
Definition: asvdec.c:40
#define ASV2_LEVEL_VLC_BITS
Definition: asvdec.c:41
#define DC_CCP_VLC_BITS
Definition: asvdec.c:38
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: asvdec.c:214
static int asv2_decode_block(ASV1Context *a, int16_t block[64])
Definition: asvdec.c:138
static int asv2_get_vlc2(GetBitContext *gb, VLC_TYPE(*table)[2], int bits)
Definition: asvdec.c:79
static void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
Definition: asvdec.c:194
static VLC asv2_level_vlc
Definition: asvdec.c:47
static av_cold void init_vlcs(void)
Definition: asvdec.c:49
static VLC dc_ccp_vlc
Definition: asvdec.c:45
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
float re
Definition: fft.c:82
static unsigned int get_bits_le(GetBitContext *s, int n)
Definition: get_bits.h:420
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
Definition: get_bits.h:685
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
#define SHOW_UBITS_LE(name, gb, num)
Definition: get_bits.h:201
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
@ AV_CODEC_ID_ASV1
Definition: codec_id.h:80
@ AV_CODEC_ID_ASV2
Definition: codec_id.h:81
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:50
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
int index
Definition: gxfenc.c:89
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
int i
Definition: input.c:407
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
#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: internal.h:41
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define emms_c()
Definition: internal.h:54
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
Memory handling functions.
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
MPEG-1/2 tables.
const char data[16]
Definition: mxf.c:142
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static const uint16_t table[]
Definition: prosumer.c:206
const uint8_t * code
Definition: spdifenc.c:413
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
enum AVCodecID codec_id
Definition: avcodec.h:546
int extradata_size
Definition: avcodec.h:638
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
Definition: vlc.h:26
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
#define av_freep(p)
#define av_log(a,...)
static int16_t block[64]
Definition: dct.c:116
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
#define INIT_LE_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:123
#define VLC_TYPE
Definition: vlc.h:24
uint8_t bits
Definition: vp3data.h:141