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,
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;
183 memset(&idsp,0,
sizeof(idsp));
186 for (i = 0; i < 64; i++)
190 for (i = 0; i < 64; i++){
217 if (partial_bit_count > 0) {
218 re_cache = re_cache >> partial_bit_count |
240 if (re_index + vlc_len > last_index) {
244 re_index = last_index;
280 int quant,
dc, dct_mode, class1, j;
281 int mb_index, mb_x, mb_y, last_index;
282 int y_stride, linesize;
294 int is_field_mode[5];
295 int vs_bit_buffer_damaged = 0;
296 int mb_bit_buffer_damaged[5] = {0};
305 memset(sblock, 0, 5 *
DV_MAX_BPM *
sizeof(*sblock));
309 block1 = &sblock[0][0];
312 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->
sys->
bpm, block1 += s->
sys->
bpm * 64) {
314 quant = buf_ptr[3] & 0x0f;
316 if ((buf_ptr[3] >> 4) == 0x0E)
317 vs_bit_buffer_damaged = 1;
319 sta = buf_ptr[3] >> 4;
320 }
else if (sta != (buf_ptr[3] >> 4))
321 vs_bit_buffer_damaged = 1;
327 is_field_mode[mb_index] = 0;
328 for (j = 0; j < s->
sys->
bpm; j++) {
342 is_field_mode[mb_index] |= !j && dct_mode;
356 buf_ptr += last_index >> 3;
360 ff_dlog(avctx,
"MB block: %d, %d ", mb_index, j);
367 if (mb->
pos >= 64 && mb->
pos < 127)
368 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
374 if (mb_bit_buffer_damaged[mb_index] > 0)
384 for (j = 0; j < s->
sys->
bpm; j++, block += 64, mb++) {
391 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
402 block = &sblock[0][0];
407 for (mb_index = 0; mb_index < 5; mb_index++) {
408 for (j = 0; j < s->
sys->
bpm; j++) {
410 ff_dlog(avctx,
"start %d:%d\n", mb_index, j);
414 if (mb->
pos >= 64 && mb->
pos < 127) {
416 "AC EOB marker is absent pos=%d\n", mb->
pos);
417 vs_bit_buffer_damaged = 1;
423 if (vs_bit_buffer_damaged && !retried) {
430 block = &sblock[0][0];
432 for (mb_index = 0; mb_index < 5; mb_index++) {
438 (s->
sys->
height >= 720 && mb_y != 134)) {
440 ((!is_field_mode[mb_index]) * log2_blocksize));
442 y_stride = (2 << log2_blocksize);
447 mb[0].
idct_put(y_ptr, linesize, block + 0 * 64);
449 mb[2].
idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
451 mb[1].
idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
452 mb[2].
idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
453 mb[3].
idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
461 for (j = 2; j; j--) {
464 uint64_t aligned_pixels[64 / 8];
469 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->
frame->
linesize[j], pixels += 8) {
470 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
472 for (x = 0; x < (1 <<
FFMAX(log2_blocksize - 1, 0)); x++) {
473 c_ptr[x] = pixels[x];
480 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
481 s->
frame->
linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
483 (mb++)->
idct_put(c_ptr, linesize, block);
486 (mb++)->
idct_put(c_ptr + y_stride, linesize, block);
501 int buf_size = avpkt->
size;
505 int apt, is16_9, ret;
535 vsc_pack = buf + 80 * 5 + 48 + 5;
538 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
539 (!apt && (vsc_pack[2] & 0x07) == 0x07);
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 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
#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)
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.
void(* idct_put[2])(uint8_t *dest, ptrdiff_t stride, int16_t *block)
static const int dv_iweight_bits