57 static const uint8_t off[] = { 2, 6, 8, 0, 4 };
58 static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
59 static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
60 static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
62 static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
63 static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
65 static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
70 static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
71 0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
74 static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0},
75 { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
76 {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
77 {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
78 {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
79 {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
80 {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
81 {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
82 {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
83 {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
84 {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
85 {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
86 {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
94 blk = (chan*11+seq)*27+slot;
96 if (chan == 0 && seq == 11) {
105 i = (4*chan + blk + off[m])%11;
108 x = shuf1[m] + (chan&1)*9 + k%9;
109 y = (i*3+k/9)*2 + (chan>>1) + 1;
111 tbl[m] = (x<<1)|(y<<9);
114 blk = (chan*10+seq)*27+slot;
116 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
119 x = shuf1[m]+(chan&1)*9 + k%9;
120 y = (i*3+k/9)*2 + (chan>>1) + 4;
123 x = remap[y][0]+((x-80)<<(y>59));
126 tbl[m] = (x<<1)|(y<<9);
129 blk = (chan*10+seq)*27+slot;
131 i = (4*chan + (seq/5) + 2*blk + off[m])%10;
132 k = (blk/5)%27 + (i&1)*3;
134 x = shuf2[m] + k%6 + 6*(chan&1);
135 y = l_start[i] + k/6 + 45*(chan>>1);
136 tbl[m] = (x<<1)|(y<<9);
141 x = shuf3[m] + slot/3;
144 tbl[m] = (x<<1)|(y<<8);
147 x = shuf3[m] + slot/3;
150 tbl[m] = (x<<1)|(y<<9);
154 k = slot + ((m==1||m==2)?3:0);
156 x = l_start_shuffled[m] + k/6;
157 y = serpent2[k] + i*6;
160 tbl[m] = (x<<2)|(y<<8);
173 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
181 uint32_t *factor1, *factor2;
182 const int *iweight1, *iweight2;
189 for (j=0; j<27; j++) {
213 for (c = 0; c < 4; c++) {
214 for (s = 0; s < 16; s++) {
215 for (i = 0; i < 64; i++) {
216 *factor1++ = (
dv100_qstep[s] << (c + 9)) * iweight1[i];
217 *factor2++ = (
dv100_qstep[s] << (c + 9)) * iweight2[i];
224 for (s = 0; s < 22; s++) {
225 for (i = c = 0; c < 4; c++) {
228 *factor2++ = (*factor1++) << 1;
256 for (i = 0, j = 0; i <
NB_DV_VLC; i++, j++) {
263 new_dv_vlc_bits[j] <<= 1;
277 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
281 int code = dv_vlc.
table[i][0];
289 run = new_dv_vlc_run [code] + 1;
290 level = new_dv_vlc_level[code];
292 ff_dv_rl_vlc[i].
len =
len;
294 ff_dv_rl_vlc[i].
run =
run;
308 for (i = 0; i < 64; i++)
327 "Valid DV profiles are:\n",
356 *vlc = 0xfe00 | (level << 1) | sign;
360 *vlc |= ((run < 16) ?
dv_vlc_map[run-1][0].vlc :
361 (0x1f80 | (run - 1))) <<
size;
362 size += (run < 16) ?
dv_vlc_map[run-1][0].size : 13;
379 size += (run < 16) ?
dv_vlc_map[run-1][0].size : 13;
426 put_bits(pb, bits_left, vlc >> size);
427 vlc = vlc & ((1 <<
size) - 1);
429 if (pb + 1 >= pb_end) {
469 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
470 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
471 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
472 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
473 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
474 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
475 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
476 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
479 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
480 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
481 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
482 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
483 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
484 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
485 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
486 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
506 static const int classes[] = {12, 24, 36, 0xffff};
508 static const int classes[] = {-1, -1, 255, 0xffff};
510 int max = classes[0];
513 assert((((
int)
blk) & 15) == 0);
526 memset(blk, 0, 64*
sizeof(*blk));
534 for (area = 0; area < 4; area++) {
535 bi->
prev[area] = prev;
538 int level = blk[zigzag_scan[i]];
540 if (level + 15 > 30
U) {
541 bi->
sign[i] = (level >> 31) & 1;
545 level = (
FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
556 for (bi->
cno = 0; max > classes[bi->
cno]; bi->
cno++);
564 for (area = 0; area < 4; area++) {
565 bi->
prev[area] = prev;
586 int i, j, k,
a, prev,
a2;
589 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
592 for (i = 0; i < 5; i++) {
598 for (j = 0; j < 6; j++, b++) {
599 for (a = 0; a < 4; a++) {
615 assert(b->
mb[b->
next[k]]);
618 assert(b->
prev[a2] == k && (a2 + 1 >= 4 || b->
prev[a2+1] != k));
632 }
while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
638 for (j = 0; j < 6 *5; j++, b++) {
640 for (k = b->
next[prev]; k < 64; k = b->next[k]) {
641 if (b->
mb[k] < a && b->
mb[k] > -a){
657 int mb_x, mb_y, c_offset, linesize, y_stride;
666 int qnos[5] = {15, 15, 15, 15, 15};
667 int* qnosp = &qnos[0];
670 enc_blk = &enc_blks[0];
671 for (mb_index = 0; mb_index < 5; mb_index++) {
677 (s->
sys->
height >= 720 && mb_y != 134)) {
703 for (j = 2; j; j--) {
710 for (i = 0; i < 8; i++) {
711 d = c_ptr + (linesize << 3);
712 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
713 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
732 for (j=0; j<5*s->
sys->
bpm;) {
739 for (i=0; i<s->
sys->
bpm; i++, j++) {
743 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
744 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
745 put_bits(&pbs[j], 2, enc_blks[j].cno);
753 for (i=0; i<s->
sys->
bpm; i++) {
754 if (enc_blks[start_mb+i].partial_bit_count)
761 for (j=0; j<5*s->
sys->
bpm; j++) {
762 if (enc_blks[j].partial_bit_count)
764 if (enc_blks[j].partial_bit_count)
768 for (j=0; j<5*s->
sys->
bpm; j++) {
777 memset(pbs[j].buf + pos, 0xff, size - pos);
850 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
855 #if CONFIG_DVVIDEO_ENCODER
861 buf[1] = (seq_num << 4) |
871 if (syb_num == 0 || syb_num == 6) {
876 else if (syb_num == 11) {
897 memset(buf, 0xff, 80 * 6);
905 for (j = 0; j < 2; j++) {
907 for (k = 0; k < 6; k++)
908 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
913 for (j = 0; j < 3; j++) {
924 for (j = 0; j < 135; j++) {
926 memset(buf, 0xff, 80);
942 const AVFrame *frame,
int *got_packet)
966 dv_format_frame(s, pkt->
data);
980 .encode2 = dvvideo_encode_frame,
987 #endif // CONFIG_DVVIDEO_ENCODER
#define CODEC_FLAG_INTERLACED_DCT
#define LOCAL_ALIGNED_8(t, v,...)
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
const uint8_t ff_zigzag_direct[64]
void ff_dv_print_profiles(void *logctx, int loglevel)
Print all allowed DV profiles into logctx at specified logging level.
This structure describes decoded (raw) audio or video data.
RL_VLC_ELEM ff_dv_rl_vlc[1184]
const int ff_dv_iweight_720_y[64]
static void put_sbits(PutBitContext *pb, int n, int32_t value)
int ff_dv_init_dynamic_tables(const DVprofile *d)
AVFrame * coded_frame
the picture in the bitstream
const uint8_t ff_zigzag248_direct[64]
static const uint8_t dv_vlc_run[NB_DV_VLC]
struct DVVideoContext DVVideoContext
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t *buf)
static void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize)
int ildct_cmp
interlaced DCT comparison function
const uint8_t ff_dv_quant_offset[4]
static const uint8_t zigzag_scan[16]
#define DV_PROFILE_IS_720p50(p)
static const int mb_area_start[5]
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
static av_always_inline int dv_rl2vlc_size(int run, int l)
void(* get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size)
enum AVPixelFormat pix_fmt
static double av_q2d(AVRational a)
Convert rational to double.
void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
static const int dv_weight_88[64]
bitstream reader API header.
uint8_t idct_permutation[64]
idct input permutation.
#define LOCAL_ALIGNED_16(t, v,...)
const uint8_t * block_sizes
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
static int init(AVCodecParserContext *s)
static int dv_work_pool_size(const DVprofile *d)
#define DV_PROFILE_IS_1080i50(p)
uint8_t partial_bit_count
static const int vs_total_ac_bits
static int put_bits_left(PutBitContext *s)
uint16_t mb_coordinates[5]
void(* idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block)
void(* idct_put)(uint8_t *dest, int line_size, DCTELEM *block)
block -> idct -> clip to unsigned 8 bit -> dest.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define DV_PROFILE_IS_HD(p)
static const int dv_weight_bits
uint32_t partial_bit_buffer
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
void ff_simple_idct248_put(uint8_t *dest, int line_size, DCTELEM *block)
int flags
A combination of AV_PKT_FLAG values.
static int put_bits_count(PutBitContext *s)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
const DVprofile * avpriv_dv_codec_profile(AVCodecContext *codec)
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
struct EncBlockInfo EncBlockInfo
#define DV_VLC_MAP_RUN_SIZE
void(* fdct248)(DCTELEM *block)
int width
picture width / height.
int ff_alloc_packet(AVPacket *avpkt, int size)
Check AVPacket size and/or allocate data.
static const uint8_t dv_vlc_len[NB_DV_VLC]
static void dv_vlc_map_tableinit(void)
static const int dv_weight_248[64]
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
static const uint8_t dv100_qstep[16]
main external API structure.
void(* fdct[2])(DCTELEM *block)
#define DV_VLC_MAP_LEV_SIZE
const int ff_dv_iweight_1080_y[64]
The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
const int ff_dv_iweight_248[64]
static const uint8_t dv_vlc_level[NB_DV_VLC]
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
#define CODEC_CAP_SLICE_THREADS
static const uint8_t dv_quant_areas[4]
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
const int ff_dv_iweight_88[64]
const int ff_dv_iweight_1080_c[64]
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
const uint8_t ff_dv_quant_shifts[22][4]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
void(* fdct)(DCTELEM *block)
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
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.
static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
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.
static void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, uint16_t *tbl)
VLC_TYPE(* table)[2]
code, bits
static const uint16_t dv_vlc_bits[NB_DV_VLC]
int key_frame
1 -> keyframe, 0-> not
const int ff_dv_iweight_720_c[64]
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
static struct dv_vlc_pair dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]
DVwork_chunk * work_chunks
AVPixelFormat
Pixel format.
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)