66 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
67 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
68 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
69 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
70 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
71 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
72 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
73 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
76 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
77 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
78 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
79 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
80 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
81 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
82 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
83 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
90 128, 16, 16, 17, 17, 17, 18, 18,
91 18, 18, 18, 18, 19, 18, 18, 19,
92 19, 19, 19, 19, 19, 42, 38, 40,
93 40, 40, 38, 42, 44, 43, 41, 41,
94 41, 41, 43, 44, 45, 45, 42, 42,
95 42, 45, 45, 48, 46, 43, 43, 46,
96 48, 49, 48, 44, 48, 49, 101, 98,
97 98, 101, 104, 109, 104, 116, 116, 123,
100 128, 16, 16, 17, 17, 17, 25, 25,
101 25, 25, 26, 25, 26, 25, 26, 26,
102 26, 27, 27, 26, 26, 42, 38, 40,
103 40, 40, 38, 42, 44, 43, 41, 41,
104 41, 41, 43, 44, 91, 91, 84, 84,
105 84, 91, 91, 96, 93, 86, 86, 93,
106 96, 197, 191, 177, 191, 197, 203, 197,
107 197, 203, 209, 219, 209, 232, 232, 246,
110 128, 16, 16, 17, 17, 17, 18, 18,
111 18, 18, 18, 18, 19, 18, 18, 19,
112 19, 19, 19, 19, 19, 42, 38, 40,
113 40, 40, 38, 42, 44, 43, 41, 41,
114 41, 41, 43, 44, 68, 68, 63, 63,
115 63, 68, 68, 96, 92, 86, 86, 92,
116 96, 98, 96, 88, 96, 98, 202, 196,
117 196, 202, 208, 218, 208, 232, 232, 246,
120 128, 24, 24, 26, 26, 26, 36, 36,
121 36, 36, 36, 36, 38, 36, 36, 38,
122 38, 38, 38, 38, 38, 84, 76, 80,
123 80, 80, 76, 84, 88, 86, 82, 82,
124 82, 82, 86, 88, 182, 182, 168, 168,
125 168, 182, 182, 192, 186, 192, 172, 186,
126 192, 394, 382, 354, 382, 394, 406, 394,
127 394, 406, 418, 438, 418, 464, 464, 492,
138 static const uint8_t dv100_qstep[16] = {
141 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
143 const uint16_t *iweight1, *iweight2;
152 for (c = 0; c < 4; c++) {
153 for (s = 0; s < 16; s++) {
154 for (i = 0; i < 64; i++) {
155 *factor1++ = (dv100_qstep[
s] << (c + 9)) * iweight1[
i];
156 *factor2++ = (dv100_qstep[
s] << (c + 9)) * iweight2[
i];
161 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
164 for (s = 0; s < 22; s++) {
165 for (i = c = 0; c < 4; c++) {
166 for (; i < dv_quant_areas[
c]; i++) {
168 *factor2++ = (*factor1++) << 1;
183 for (i = 0; i < 64; i++)
187 for (i = 0; i < 64; i++){
214 if (partial_bit_count > 0) {
215 re_cache = re_cache >> partial_bit_count |
237 if (re_index + vlc_len > last_index) {
241 re_index = last_index;
276 for (i = 0; i < 4; i++) {
277 for (j = 0; j < 8; j++)
278 p[j] = av_clip_uint8(block[j]);
285 int stride, int16_t *blocks)
293 put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
297 int stride, int16_t *blocks)
309 put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
311 put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
319 int quant,
dc, dct_mode, class1, j;
320 int mb_index, mb_x, mb_y, last_index;
321 int y_stride, linesize;
333 int is_field_mode[5];
334 int vs_bit_buffer_damaged = 0;
335 int mb_bit_buffer_damaged[5] = {0};
344 memset(sblock, 0, 5 *
DV_MAX_BPM *
sizeof(*sblock));
348 block1 = &sblock[0][0];
351 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->
sys->
bpm, block1 += s->
sys->
bpm * 64) {
353 quant = buf_ptr[3] & 0x0f;
355 if ((buf_ptr[3] >> 4) == 0x0E)
356 vs_bit_buffer_damaged = 1;
358 sta = buf_ptr[3] >> 4;
359 }
else if (sta != (buf_ptr[3] >> 4))
360 vs_bit_buffer_damaged = 1;
366 is_field_mode[mb_index] = 0;
367 for (j = 0; j < s->
sys->
bpm; j++) {
381 is_field_mode[mb_index] |= !j && dct_mode;
395 buf_ptr += last_index >> 3;
399 ff_dlog(avctx,
"MB block: %d, %d ", mb_index, j);
406 if (mb->
pos >= 64 && mb->
pos < 127)
407 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
413 if (mb_bit_buffer_damaged[mb_index] > 0)
423 for (j = 0; j < s->
sys->
bpm; j++, block += 64, mb++) {
430 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
441 block = &sblock[0][0];
446 for (mb_index = 0; mb_index < 5; mb_index++) {
447 for (j = 0; j < s->
sys->
bpm; j++) {
449 ff_dlog(avctx,
"start %d:%d\n", mb_index, j);
453 if (mb->
pos >= 64 && mb->
pos < 127) {
455 "AC EOB marker is absent pos=%d\n", mb->
pos);
456 vs_bit_buffer_damaged = 1;
462 if (vs_bit_buffer_damaged && !retried) {
469 block = &sblock[0][0];
471 for (mb_index = 0; mb_index < 5; mb_index++) {
477 (s->
sys->
height >= 720 && mb_y != 134)) {
479 ((!is_field_mode[mb_index]) * log2_blocksize));
481 y_stride = (2 << log2_blocksize);
485 if (mb_y == 134 && is_field_mode[mb_index]) {
489 mb[0].
idct_put(y_ptr, linesize, block + 0 * 64);
491 mb[2].
idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
493 mb[1].
idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
494 mb[2].
idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
495 mb[3].
idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
504 for (j = 2; j; j--) {
507 uint64_t aligned_pixels[64 / 8];
512 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->
frame->
linesize[j], pixels += 8) {
513 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
515 for (x = 0; x < (1 <<
FFMAX(log2_blocksize - 1, 0)); x++) {
516 c_ptr[x] = pixels[x];
523 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
524 s->
frame->
linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
525 if (mb_y == 134 && is_field_mode[mb_index]) {
531 (mb++)->
idct_put(c_ptr, linesize, block);
534 (mb++)->
idct_put(c_ptr + y_stride, linesize, block);
550 int buf_size = avpkt->
size;
554 int apt, is16_9, ret;
584 vsc_pack = buf + 80 * 5 + 48 + 5;
587 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
588 (!apt && (vsc_pack[2] & 0x07) == 0x07);
597 if (avctx->
height == 720) {
600 }
else if (avctx->
height == 1080) {
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
uint32_t idct_factor[2 *4 *16 *64]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
const uint8_t * block_sizes
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.
static av_cold int init(AVCodecContext *avctx)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
const uint8_t ff_dv_quant_offset[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_88[64]
static int get_sbits(GetBitContext *s, int n)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
const uint8_t ff_dv_zigzag248_direct[64]
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.
Multithreading support functions.
#define u(width, name, range_min, range_max)
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
enum AVPixelFormat pix_fmt
static int get_bits_left(GetBitContext *gb)
DVwork_chunk work_chunks[4 *12 *27]
#define UPDATE_CACHE(name, gb)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void bit_copy(PutBitContext *pb, GetBitContext *gb)
static const uint16_t dv_iweight_720_y[64]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int error_concealment
error concealment flags
static int dv_work_pool_size(const AVDVProfile *d)
AVCodec ff_dvvideo_decoder
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
#define CLOSE_READER(name, gb)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
static int put_bits_count(PutBitContext *s)
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data, int stride, int16_t *blocks)
#define DV_PROFILE_IS_HD(p)
uint32_t partial_bit_buffer
RL_VLC_ELEM ff_dv_rl_vlc[1664]
static const uint16_t dv_iweight_1080_y[64]
The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
const uint8_t * scan_table
uint8_t idct_permutation[64]
IDCT input permutation.
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
#define SHOW_UBITS(name, gb, num)
static const uint16_t dv_iweight_720_c[64]
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
static int dvvideo_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Libavcodec external API header.
const uint32_t * factor_table
typedef void(RENAME(mix_any_func_type))
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
static unsigned int get_bits1(GetBitContext *s)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
const uint8_t ff_zigzag_direct[64]
uint8_t partial_bit_count
static const uint16_t dv_iweight_1080_c[64]
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
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
static const uint16_t dv_iweight_248[64]
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
const uint8_t ff_dv_quant_shifts[22][4]
#define OPEN_READER_NOSIZE(name, gb)
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
int ff_dv_init_dynamic_tables(DVVideoContext *ctx, const AVDVProfile *d)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
int top_field_first
If the content is interlaced, is top field displayed first.
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
int key_frame
1 -> keyframe, 0-> not
static int16_t block1[64]
void(* idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block)
#define LOCAL_ALIGNED_16(t, v,...)
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
void(* idct)(int16_t *block)
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.
This structure stores compressed data.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data, int stride, int16_t *blocks)
void(* idct_put[2])(uint8_t *dest, ptrdiff_t stride, int16_t *block)
static const int dv_iweight_bits