67 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
68 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
69 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
70 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
71 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
72 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
73 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
74 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
77 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
78 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
79 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
80 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
81 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
82 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
83 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
84 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
91 128, 16, 16, 17, 17, 17, 18, 18,
92 18, 18, 18, 18, 19, 18, 18, 19,
93 19, 19, 19, 19, 19, 42, 38, 40,
94 40, 40, 38, 42, 44, 43, 41, 41,
95 41, 41, 43, 44, 45, 45, 42, 42,
96 42, 45, 45, 48, 46, 43, 43, 46,
97 48, 49, 48, 44, 48, 49, 101, 98,
98 98, 101, 104, 109, 104, 116, 116, 123,
101 128, 16, 16, 17, 17, 17, 25, 25,
102 25, 25, 26, 25, 26, 25, 26, 26,
103 26, 27, 27, 26, 26, 42, 38, 40,
104 40, 40, 38, 42, 44, 43, 41, 41,
105 41, 41, 43, 44, 91, 91, 84, 84,
106 84, 91, 91, 96, 93, 86, 86, 93,
107 96, 197, 191, 177, 191, 197, 203, 197,
108 197, 203, 209, 219, 209, 232, 232, 246,
111 128, 16, 16, 17, 17, 17, 18, 18,
112 18, 18, 18, 18, 19, 18, 18, 19,
113 19, 19, 19, 19, 19, 42, 38, 40,
114 40, 40, 38, 42, 44, 43, 41, 41,
115 41, 41, 43, 44, 68, 68, 63, 63,
116 63, 68, 68, 96, 92, 86, 86, 92,
117 96, 98, 96, 88, 96, 98, 202, 196,
118 196, 202, 208, 218, 208, 232, 232, 246,
121 128, 24, 24, 26, 26, 26, 36, 36,
122 36, 36, 36, 36, 38, 36, 36, 38,
123 38, 38, 38, 38, 38, 84, 76, 80,
124 80, 80, 76, 84, 88, 86, 82, 82,
125 82, 82, 86, 88, 182, 182, 168, 168,
126 168, 182, 182, 192, 186, 192, 172, 186,
127 192, 394, 382, 354, 382, 394, 406, 394,
128 394, 406, 418, 438, 418, 464, 464, 492,
134 uint32_t *factor1 = &
ctx->idct_factor[0],
139 static const uint8_t dv100_qstep[16] = {
142 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
144 const uint16_t *iweight1, *iweight2;
153 for (
c = 0;
c < 4;
c++) {
154 for (
s = 0;
s < 16;
s++) {
155 for (
i = 0;
i < 64;
i++) {
156 *factor1++ = (dv100_qstep[
s] << (
c + 9)) * iweight1[
i];
157 *factor2++ = (dv100_qstep[
s] << (
c + 9)) * iweight2[
i];
162 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
165 for (
s = 0;
s < 22;
s++) {
166 for (
i =
c = 0;
c < 4;
c++) {
167 for (;
i < dv_quant_areas[
c];
i++) {
169 *factor2++ = (*factor1++) << 1;
184 for (
i = 0;
i < 64;
i++)
188 for (
i = 0;
i < 64;
i++){
190 s->dv_zigzag[1][
i] =
s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
195 s->idct_put[0] =
s->idsp.idct_put;
205 const uint8_t *scan_table =
mb->scan_table;
206 const uint32_t *factor_table =
mb->factor_table;
208 int partial_bit_count =
mb->partial_bit_count;
215 if (partial_bit_count > 0) {
216 re_cache = re_cache >> partial_bit_count |
217 mb->partial_bit_buffer;
218 re_index -= partial_bit_count;
219 mb->partial_bit_count = 0;
238 if (re_index + vlc_len > last_index) {
240 mb->partial_bit_count = last_index - re_index;
241 mb->partial_bit_buffer = re_cache & ~(-1u >>
mb->partial_bit_count);
242 re_index = last_index;
277 for (
i = 0;
i < 4;
i++) {
278 for (j = 0; j < 8; j++)
286 int stride, int16_t *blocks)
288 s->idsp.idct(blocks + 0*64);
289 s->idsp.idct(blocks + 1*64);
298 int stride, int16_t *blocks)
300 s->idsp.idct(blocks + 0*64);
301 s->idsp.idct(blocks + 1*64);
302 s->idsp.idct(blocks + 2*64);
303 s->idsp.idct(blocks + 3*64);
320 int quant,
dc, dct_mode, class1, j;
321 int mb_index, mb_x, mb_y, last_index;
322 int y_stride, linesize;
333 const int log2_blocksize = 3-
s->avctx->lowres;
334 int is_field_mode[5];
335 int vs_bit_buffer_damaged = 0;
336 int mb_bit_buffer_damaged[5] = {0};
345 memset(sblock, 0, 5 *
DV_MAX_BPM *
sizeof(*sblock));
352 for (mb_index = 0; mb_index < 5; mb_index++, mb1 +=
s->sys->bpm,
block1 +=
s->sys->bpm * 64) {
354 quant = buf_ptr[3] & 0x0f;
356 if ((buf_ptr[3] >> 4) == 0x0E)
357 vs_bit_buffer_damaged = 1;
359 sta = buf_ptr[3] >> 4;
360 }
else if (sta != (buf_ptr[3] >> 4))
361 vs_bit_buffer_damaged = 1;
367 is_field_mode[mb_index] = 0;
368 for (j = 0; j <
s->sys->bpm; j++) {
369 last_index =
s->sys->block_sizes[j];
377 mb->idct_put =
s->idct_put[0];
378 mb->scan_table =
s->dv_zigzag[0];
379 mb->factor_table = &
s->idct_factor[(j >= 4) * 4 * 16 * 64 +
382 is_field_mode[mb_index] |= !j && dct_mode;
384 mb->idct_put =
s->idct_put[dct_mode && log2_blocksize == 3];
385 mb->scan_table =
s->dv_zigzag[dct_mode];
387 &
s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
396 buf_ptr += last_index >> 3;
398 mb->partial_bit_count = 0;
400 ff_dlog(avctx,
"MB block: %d, %d ", mb_index, j);
407 if (
mb->pos >= 64 &&
mb->pos < 127)
408 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
414 if (mb_bit_buffer_damaged[mb_index] > 0)
424 for (j = 0; j <
s->sys->bpm; j++,
block += 64,
mb++) {
431 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
436 if (j >=
s->sys->bpm)
442 block = &sblock[0][0];
447 for (mb_index = 0; mb_index < 5; mb_index++) {
448 for (j = 0; j <
s->sys->bpm; j++) {
449 if (
mb->pos < 64 &&
get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
450 ff_dlog(avctx,
"start %d:%d\n", mb_index, j);
454 if (
mb->pos >= 64 &&
mb->pos < 127) {
456 "AC EOB marker is absent pos=%d\n",
mb->pos);
457 vs_bit_buffer_damaged = 1;
463 if (vs_bit_buffer_damaged && !retried) {
470 block = &sblock[0][0];
472 for (mb_index = 0; mb_index < 5; mb_index++) {
478 (
s->sys->height >= 720 && mb_y != 134)) {
479 y_stride = (
s->frame->linesize[0] <<
480 ((!is_field_mode[mb_index]) * log2_blocksize));
482 y_stride = (2 << log2_blocksize);
484 y_ptr =
s->frame->data[0] +
485 ((mb_y *
s->frame->linesize[0] + mb_x) << log2_blocksize);
486 if (mb_y == 134 && is_field_mode[mb_index]) {
489 linesize =
s->frame->linesize[0] << is_field_mode[mb_index];
490 mb[0].idct_put(y_ptr, linesize,
block + 0 * 64);
491 if (
s->sys->video_stype == 4) {
492 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize,
block + 2 * 64);
494 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize,
block + 1 * 64);
495 mb[2].idct_put(y_ptr + y_stride, linesize,
block + 2 * 64);
496 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize,
block + 3 * 64);
505 for (j = 2; j; j--) {
506 uint8_t *c_ptr =
s->frame->data[j] + c_offset;
508 uint64_t aligned_pixels[64 / 8];
512 mb->idct_put(pixels, 8,
block);
513 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr +=
s->frame->linesize[j], pixels += 8) {
514 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
515 c_ptr1 = c_ptr + (
s->frame->linesize[j] << log2_blocksize);
516 for (x = 0; x < (1 <<
FFMAX(log2_blocksize - 1, 0)); x++) {
517 c_ptr[x] = pixels[x];
524 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
525 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
526 if (mb_y == 134 && is_field_mode[mb_index]) {
531 linesize =
s->frame->linesize[j] << is_field_mode[mb_index];
534 if (
s->sys->bpm == 8) {
551 int buf_size = avpkt->
size;
555 int apt, is16_9, ret;
585 vsc_pack = buf + 80 * 5 + 48 + 5;
588 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
589 (!apt && (vsc_pack[2] & 0x07) == 0x07);
598 if (avctx->
height == 720) {
601 }
else if (avctx->
height == 1080) {
619 return s->sys->frame_size;
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)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
const AVDVProfile * ff_dv_frame_profile(AVCodecContext *codec, const AVDVProfile *sys, const uint8_t *frame, unsigned buf_size)
Get a DV profile for the provided compressed frame.
const uint8_t ff_dv_quant_offset[4]
const uint8_t ff_dv_zigzag248_direct[64]
const uint8_t ff_dv_quant_shifts[22][4]
static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride)
static const uint16_t dv_iweight_1080_y[64]
The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
AVCodec ff_dvvideo_decoder
static const uint16_t dv_iweight_720_c[64]
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
static const uint16_t dv_iweight_248[64]
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data, int stride, int16_t *blocks)
static const uint16_t dv_iweight_720_y[64]
static const uint16_t dv_iweight_88[64]
static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data, int stride, int16_t *blocks)
static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
static const int dv_iweight_bits
static const uint16_t dv_iweight_1080_c[64]
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
bitstream reader API header.
static int get_sbits(GetBitContext *s, int n)
#define CLOSE_READER(name, gb)
static int get_bits_left(GetBitContext *gb)
#define SHOW_UBITS(name, gb, num)
static unsigned int get_bits1(GetBitContext *s)
#define OPEN_READER_NOSIZE(name, gb)
#define UPDATE_CACHE(name, gb)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
@ AV_PICTURE_TYPE_I
Intra.
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static void idct_put(FourXContext *f, int x, int y)
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
RL_VLC_ELEM ff_dv_rl_vlc[1664]
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
static int dv_work_pool_size(const AVDVProfile *d)
#define DV_PROFILE_IS_HD(p)
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
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.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
const uint8_t ff_zigzag_direct[64]
#define LOCAL_ALIGNED_16(t, v,...)
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
static int put_bits_count(PutBitContext *s)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
typedef void(RENAME(mix_any_func_type))
void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int error_concealment
error concealment flags
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.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
const char * name
Name of the codec implementation.
int key_frame
1 -> keyframe, 0-> not
int top_field_first
If the content is interlaced, is top field displayed first.
int interlaced_frame
The content of the picture is interlaced.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
void(* idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
uint32_t partial_bit_buffer
const uint32_t * factor_table
const uint8_t * scan_table
uint8_t partial_bit_count
static int16_t block1[64]