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;
184 for (i = 0; i < 64; i++)
188 for (i = 0; i < 64; i++){
215 if (partial_bit_count > 0) {
216 re_cache = re_cache >> partial_bit_count |
238 if (re_index + vlc_len > last_index) {
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)
294 put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
298 int stride, int16_t *blocks)
310 put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
312 put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
320 int quant,
dc, dct_mode, class1, j;
321 int mb_index, mb_x, mb_y, last_index;
322 int y_stride, linesize;
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));
349 block1 = &sblock[0][0];
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++) {
382 is_field_mode[mb_index] |= !j && dct_mode;
396 buf_ptr += last_index >> 3;
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;
442 block = &sblock[0][0];
447 for (mb_index = 0; mb_index < 5; mb_index++) {
448 for (j = 0; j < s->
sys->
bpm; j++) {
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)) {
480 ((!is_field_mode[mb_index]) * log2_blocksize));
482 y_stride = (2 << log2_blocksize);
486 if (mb_y == 134 && is_field_mode[mb_index]) {
490 mb[0].
idct_put(y_ptr, linesize, block + 0 * 64);
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--) {
508 uint64_t aligned_pixels[64 / 8];
513 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->
frame->
linesize[j], pixels += 8) {
514 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
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]) {
532 (mb++)->
idct_put(c_ptr, linesize, block);
535 (mb++)->
idct_put(c_ptr + y_stride, linesize, block);
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) {
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
ptrdiff_t const GLvoid * data
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)
#define LOCAL_ALIGNED_16(t, v,...)
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
The exact code depends on how similar the blocks are and how related they are to the block
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.
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
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 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)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
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
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
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
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.
main external API structure.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
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 * 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]
GLint GLenum GLboolean GLsizei stride
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)
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() or get_encode_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