Libav
dvdec.c
Go to the documentation of this file.
1 /*
2  * DV decoder
3  * Copyright (c) 2002 Fabrice Bellard
4  * Copyright (c) 2004 Roman Shaposhnik
5  *
6  * 50 Mbps (DVCPRO50) support
7  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
8  *
9  * 100 Mbps (DVCPRO HD) support
10  * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
11  * Final code by Roman Shaposhnik
12  *
13  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
14  * of DV technical info.
15  *
16  * This file is part of Libav.
17  *
18  * Libav is free software; you can redistribute it and/or
19  * modify it under the terms of the GNU Lesser General Public
20  * License as published by the Free Software Foundation; either
21  * version 2.1 of the License, or (at your option) any later version.
22  *
23  * Libav is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26  * Lesser General Public License for more details.
27  *
28  * You should have received a copy of the GNU Lesser General Public
29  * License along with Libav; if not, write to the Free Software
30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31  */
32 
38 #include "libavutil/imgutils.h"
39 #include "libavutil/internal.h"
40 #include "libavutil/pixdesc.h"
41 
42 #include "avcodec.h"
43 #include "dv.h"
44 #include "dvdata.h"
45 #include "get_bits.h"
46 #include "idctdsp.h"
47 #include "internal.h"
48 #include "put_bits.h"
49 #include "simple_idct.h"
50 
51 typedef struct BlockInfo {
52  const uint32_t *factor_table;
54  uint8_t pos; /* position in block */
55  void (*idct_put)(uint8_t *dest, int line_size, int16_t *block);
59 } BlockInfo;
60 
61 static const int dv_iweight_bits = 14;
62 
64 {
65  DVVideoContext *s = avctx->priv_data;
66  IDCTDSPContext idsp;
67  int i;
68 
69  ff_idctdsp_init(&idsp, avctx);
70 
71  for (i = 0; i < 64; i++)
72  s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
73 
74  memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
75 
76  s->idct_put[0] = idsp.idct_put;
78 
79  return ff_dvvideo_init(avctx);
80 }
81 
82 /* decode AC coefficients */
83 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
84 {
85  int last_index = gb->size_in_bits;
86  const uint8_t *scan_table = mb->scan_table;
87  const uint32_t *factor_table = mb->factor_table;
88  int pos = mb->pos;
90  int level, run, vlc_len, index;
91 
93  UPDATE_CACHE(re, gb);
94 
95  /* if we must parse a partial VLC, we do it here */
96  if (partial_bit_count > 0) {
97  re_cache = re_cache >> partial_bit_count |
99  re_index -= partial_bit_count;
100  mb->partial_bit_count = 0;
101  }
102 
103  /* get the AC coefficients until last_index is reached */
104  for (;;) {
105  ff_dlog(NULL, "%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16),
106  re_index);
107  /* our own optimized GET_RL_VLC */
108  index = NEG_USR32(re_cache, TEX_VLC_BITS);
109  vlc_len = ff_dv_rl_vlc[index].len;
110  if (vlc_len < 0) {
111  index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
113  vlc_len = TEX_VLC_BITS - vlc_len;
114  }
115  level = ff_dv_rl_vlc[index].level;
116  run = ff_dv_rl_vlc[index].run;
117 
118  /* gotta check if we're still within gb boundaries */
119  if (re_index + vlc_len > last_index) {
120  /* should be < 16 bits otherwise a codeword could have been parsed */
121  mb->partial_bit_count = last_index - re_index;
122  mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
123  re_index = last_index;
124  break;
125  }
126  re_index += vlc_len;
127 
128  ff_dlog(NULL, "run=%d level=%d\n", run, level);
129  pos += run;
130  if (pos >= 64)
131  break;
132 
133  level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
135  block[scan_table[pos]] = level;
136 
137  UPDATE_CACHE(re, gb);
138  }
139  CLOSE_READER(re, gb);
140  mb->pos = pos;
141 }
142 
143 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
144 {
145  int bits_left = get_bits_left(gb);
146  while (bits_left >= MIN_CACHE_BITS) {
148  bits_left -= MIN_CACHE_BITS;
149  }
150  if (bits_left > 0)
151  put_bits(pb, bits_left, get_bits(gb, bits_left));
152 }
153 
154 /* mb_x and mb_y are in units of 8 pixels */
155 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
156 {
157  DVVideoContext *s = avctx->priv_data;
158  DVwork_chunk *work_chunk = arg;
159  int quant, dc, dct_mode, class1, j;
160  int mb_index, mb_x, mb_y, last_index;
161  int y_stride, linesize;
162  int16_t *block, *block1;
163  int c_offset;
164  uint8_t *y_ptr;
165  const uint8_t *buf_ptr;
166  PutBitContext pb, vs_pb;
167  GetBitContext gb;
168  BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
169  LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
170  LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
171  LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
172  const int log2_blocksize = 3;
173  int is_field_mode[5];
174 
175  assert((((int) mb_bit_buffer) & 7) == 0);
176  assert((((int) vs_bit_buffer) & 7) == 0);
177 
178  memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
179 
180  /* pass 1: read DC and AC coefficients in blocks */
181  buf_ptr = &s->buf[work_chunk->buf_offset * 80];
182  block1 = &sblock[0][0];
183  mb1 = mb_data;
184  init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
185  for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
186  /* skip header */
187  quant = buf_ptr[3] & 0x0f;
188  buf_ptr += 4;
189  init_put_bits(&pb, mb_bit_buffer, 80);
190  mb = mb1;
191  block = block1;
192  is_field_mode[mb_index] = 0;
193  for (j = 0; j < s->sys->bpm; j++) {
194  last_index = s->sys->block_sizes[j];
195  init_get_bits(&gb, buf_ptr, last_index);
196 
197  /* get the DC */
198  dc = get_sbits(&gb, 9);
199  dct_mode = get_bits1(&gb);
200  class1 = get_bits(&gb, 2);
201  if (DV_PROFILE_IS_HD(s->sys)) {
202  mb->idct_put = s->idct_put[0];
203  mb->scan_table = s->dv_zigzag[0];
204  mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
205  class1 * 16 * 64 +
206  quant * 64];
207  is_field_mode[mb_index] |= !j && dct_mode;
208  } else {
209  mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
210  mb->scan_table = s->dv_zigzag[dct_mode];
211  mb->factor_table =
212  &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
213  dct_mode * 22 * 64 +
214  (quant + ff_dv_quant_offset[class1]) * 64];
215  }
216  dc = dc << 2;
217  /* convert to unsigned because 128 is not added in the
218  * standard IDCT */
219  dc += 1024;
220  block[0] = dc;
221  buf_ptr += last_index >> 3;
222  mb->pos = 0;
223  mb->partial_bit_count = 0;
224 
225  ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
226  dv_decode_ac(&gb, mb, block);
227 
228  /* write the remaining bits in a new buffer only if the
229  * block is finished */
230  if (mb->pos >= 64)
231  bit_copy(&pb, &gb);
232 
233  block += 64;
234  mb++;
235  }
236 
237  /* pass 2: we can do it just after */
238  ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
239  block = block1;
240  mb = mb1;
241  init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
242  put_bits32(&pb, 0); // padding must be zeroed
243  flush_put_bits(&pb);
244  for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
245  if (mb->pos < 64 && get_bits_left(&gb) > 0) {
246  dv_decode_ac(&gb, mb, block);
247  /* if still not finished, no need to parse other blocks */
248  if (mb->pos < 64)
249  break;
250  }
251  }
252  /* all blocks are finished, so the extra bytes can be used at
253  * the video segment level */
254  if (j >= s->sys->bpm)
255  bit_copy(&vs_pb, &gb);
256  }
257 
258  /* we need a pass over the whole video segment */
259  ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
260  block = &sblock[0][0];
261  mb = mb_data;
262  init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
263  put_bits32(&vs_pb, 0); // padding must be zeroed
264  flush_put_bits(&vs_pb);
265  for (mb_index = 0; mb_index < 5; mb_index++) {
266  for (j = 0; j < s->sys->bpm; j++) {
267  if (mb->pos < 64) {
268  ff_dlog(avctx, "start %d:%d\n", mb_index, j);
269  dv_decode_ac(&gb, mb, block);
270  }
271  if (mb->pos >= 64 && mb->pos < 127)
272  av_log(avctx, AV_LOG_ERROR,
273  "AC EOB marker is absent pos=%d\n", mb->pos);
274  block += 64;
275  mb++;
276  }
277  }
278 
279  /* compute idct and place blocks */
280  block = &sblock[0][0];
281  mb = mb_data;
282  for (mb_index = 0; mb_index < 5; mb_index++) {
283  dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
284 
285  /* idct_put'ting luminance */
286  if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
287  (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
288  (s->sys->height >= 720 && mb_y != 134)) {
289  y_stride = (s->frame->linesize[0] <<
290  ((!is_field_mode[mb_index]) * log2_blocksize));
291  } else {
292  y_stride = (2 << log2_blocksize);
293  }
294  y_ptr = s->frame->data[0] +
295  ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
296  linesize = s->frame->linesize[0] << is_field_mode[mb_index];
297  mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
298  if (s->sys->video_stype == 4) { /* SD 422 */
299  mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
300  } else {
301  mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
302  mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
303  mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
304  }
305  mb += 4;
306  block += 4 * 64;
307 
308  /* idct_put'ting chrominance */
309  c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
310  (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
311  for (j = 2; j; j--) {
312  uint8_t *c_ptr = s->frame->data[j] + c_offset;
313  if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
314  uint64_t aligned_pixels[64 / 8];
315  uint8_t *pixels = (uint8_t *) aligned_pixels;
316  uint8_t *c_ptr1, *ptr1;
317  int x, y;
318  mb->idct_put(pixels, 8, block);
319  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
320  ptr1 = pixels + (1 << (log2_blocksize - 1));
321  c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
322  for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
323  c_ptr[x] = pixels[x];
324  c_ptr1[x] = ptr1[x];
325  }
326  }
327  block += 64;
328  mb++;
329  } else {
330  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
331  s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
332  linesize = s->frame->linesize[j] << is_field_mode[mb_index];
333  (mb++)->idct_put(c_ptr, linesize, block);
334  block += 64;
335  if (s->sys->bpm == 8) {
336  (mb++)->idct_put(c_ptr + y_stride, linesize, block);
337  block += 64;
338  }
339  }
340  }
341  }
342  return 0;
343 }
344 
345 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
346  * 144000 bytes for PAL - or twice those for 50Mbps) */
347 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
348  int *got_frame, AVPacket *avpkt)
349 {
350  uint8_t *buf = avpkt->data;
351  int buf_size = avpkt->size;
352  DVVideoContext *s = avctx->priv_data;
353  AVFrame *frame = data;
354  const uint8_t *vsc_pack;
355  int apt, is16_9, ret;
356  const AVDVProfile *sys;
357 
358  sys = av_dv_frame_profile(s->sys, buf, buf_size);
359  if (!sys || buf_size < sys->frame_size) {
360  av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
361  return -1; /* NOTE: we only accept several full frames */
362  }
363 
364  if (sys != s->sys) {
365  ret = ff_dv_init_dynamic_tables(s, sys);
366  if (ret < 0) {
367  av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
368  return ret;
369  }
370  s->sys = sys;
371  }
372 
373  s->frame = frame;
374  frame->key_frame = 1;
375  frame->pict_type = AV_PICTURE_TYPE_I;
376  avctx->pix_fmt = s->sys->pix_fmt;
377  avctx->framerate = av_inv_q(s->sys->time_base);
378 
379  ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
380  if (ret < 0)
381  return ret;
382 
383  /* Determine the codec's sample_aspect ratio from the packet */
384  vsc_pack = buf + 80 * 5 + 48 + 5;
385  if (*vsc_pack == dv_video_control) {
386  apt = buf[4] & 0x07;
387  is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
388  (!apt && (vsc_pack[2] & 0x07) == 0x07);
389  ff_set_sar(avctx, s->sys->sar[is16_9]);
390  }
391 
392  if (ff_get_buffer(avctx, frame, 0) < 0) {
393  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
394  return -1;
395  }
396  frame->interlaced_frame = 1;
397  frame->top_field_first = 0;
398 
399  s->buf = buf;
400  avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
401  dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
402 
403  emms_c();
404 
405  /* return image */
406  *got_frame = 1;
407 
408  return s->sys->frame_size;
409 }
410 
412  .name = "dvvideo",
413  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
414  .type = AVMEDIA_TYPE_VIDEO,
415  .id = AV_CODEC_ID_DVVIDEO,
416  .priv_data_size = sizeof(DVVideoContext),
420 };
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:182
AVRational framerate
Definition: avcodec.h:3063
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
RL_VLC_ELEM ff_dv_rl_vlc[1184]
Definition: dv.c:52
uint32_t idct_factor[2 *4 *16 *64]
Definition: dv.h:53
float re
Definition: fft.c:69
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
const uint8_t * block_sizes
Definition: dv_profile.h:47
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:134
static const uint8_t frame_size[4]
Definition: g723_1.h:219
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1621
uint8_t run
Definition: svq3.c:203
const uint8_t ff_dv_quant_offset[4]
Definition: dvdata.c:70
AVCodec.
Definition: avcodec.h:3120
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:214
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
Definition: dvdec.c:55
uint8_t * buf
Definition: dv.h:44
static int16_t block[64]
Definition: dct.c:97
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
Definition: dvdec.c:63
uint8_t
#define av_cold
Definition: attributes.h:66
void(* idct_put[2])(uint8_t *dest, int line_size, int16_t *block)
Definition: dv.h:50
const uint8_t ff_dv_zigzag248_direct[64]
Definition: dvdata.c:33
#define emms_c()
Definition: internal.h:48
void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:88
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:1346
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:146
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:263
enum AVPixelFormat pix_fmt
Definition: dv_profile.h:45
AVRational time_base
Definition: dv_profile.h:40
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:526
DVwork_chunk work_chunks[4 *12 *27]
Definition: dv.h:52
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:149
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
Definition: dvdec.c:143
int shift_offset
Definition: dvdec.c:58
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
static int dv_work_pool_size(const AVDVProfile *d)
Definition: dv.h:104
const AVDVProfile * av_dv_frame_profile(const AVDVProfile *sys, const uint8_t *frame, unsigned buf_size)
Get a DV profile for the provided compressed frame.
Definition: dv_profile.c:259
AVCodec ff_dvvideo_decoder
Definition: dvdec.c:411
int frame_size
Definition: dv_profile.h:37
const AVFrame * frame
Definition: dv.h:42
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:134
#define CLOSE_READER(name, gb)
Definition: get_bits.h:129
int8_t len
Definition: vlc.h:34
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
common internal API header
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:70
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:201
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
Definition: dv.h:95
#define NEG_USR32(a, s)
Definition: mathops.h:154
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: avconv.c:1288
int size_in_bits
Definition: get_bits.h:57
#define DV_PROFILE_IS_HD(p)
Definition: dv.h:79
uint32_t partial_bit_buffer
Definition: dvdec.c:57
const uint8_t * scan_table
Definition: dvdec.c:53
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:176
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:897
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: dvdec.c:347
NULL
Definition: eval.c:55
Libavcodec external API header.
const uint32_t * factor_table
Definition: dvdec.c:52
#define ff_dlog(ctx,...)
Definition: internal.h:60
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
Definition: dvdec.c:155
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:158
uint8_t pos
Definition: dvdec.c:54
main external API structure.
Definition: avcodec.h:1409
static void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:589
uint8_t dv_zigzag[2][64]
Definition: dv.h:46
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
AVRational sar[2]
Definition: dv_profile.h:44
int index
Definition: gxfenc.c:72
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:362
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
Definition: dv.c:241
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:115
int video_stype
Definition: dv_profile.h:36
uint8_t partial_bit_count
Definition: dvdec.c:56
#define u(width,...)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
const uint8_t * quant
#define MIN_CACHE_BITS
Definition: get_bits.h:110
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:122
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
uint8_t level
Definition: svq3.c:204
uint8_t run
Definition: vlc.h:35
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:59
#define OPEN_READER_NOSIZE(name, gb)
Definition: get_bits.h:113
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:83
#define TEX_VLC_BITS
Definition: dv.h:97
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:66
Constants for DV codec.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
Definition: dv.c:184
uint16_t buf_offset
Definition: dv.h:36
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:638
void * priv_data
Definition: avcodec.h:1451
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:147
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:268
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
Definition: dv.h:114
simple idct header.
const AVDVProfile * sys
Definition: dv.h:41
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:196
int16_t level
Definition: vlc.h:33
static int16_t block1[64]
Definition: dct.c:98
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:111
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
Definition: dvdec.c:83
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2846
This structure stores compressed data.
Definition: avcodec.h:1323
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:838
static const int dv_iweight_bits
Definition: dvdec.c:61
bitstream writer API