42 #include "libavutil/pixdesc.h"
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++) {
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;
300 memset(&dsp,0,
sizeof(dsp));
309 for (i = 0; i < 64; i++)
316 for (i = 0; i < 64; i++){
335 "Valid DV profiles are:\n",
340 if (avctx->
height > 576) {
368 *vlc = 0xfe00 | (level << 1) | sign;
372 *vlc |= ((run < 16) ?
dv_vlc_map[run-1][0].vlc :
373 (0x1f80 | (run - 1))) <<
size;
374 size += (run < 16) ?
dv_vlc_map[run-1][0].size : 13;
391 size += (run < 16) ?
dv_vlc_map[run-1][0].size : 13;
438 put_bits(pb, bits_left, vlc >> size);
439 vlc = vlc & ((1 <<
size) - 1);
441 if (pb + 1 >= pb_end) {
468 int ps = s->
ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
470 int is = s->
ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
471 s->
ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
481 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
482 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
483 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
484 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
485 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
486 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
487 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
488 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
491 131072, 242189, 257107, 237536, 229376, 200636, 242189, 223754,
492 224969, 196781, 262144, 242189, 229376, 200636, 257107, 237536,
493 211916, 185364, 235923, 217965, 229376, 211916, 206433, 180568,
494 242189, 223754, 224969, 196781, 211916, 185364, 235923, 217965,
495 200704, 175557, 222935, 205965, 200636, 185364, 195068, 170627,
496 229376, 211916, 206433, 180568, 200704, 175557, 222935, 205965,
497 175557, 153560, 188995, 174609, 165371, 144651, 200636, 185364,
498 195068, 170627, 175557, 153560, 188995, 174609, 165371, 144651,
518 static const int classes[] = {12, 24, 36, 0xffff};
520 static const int classes[] = {-1, -1, 255, 0xffff};
522 int max = classes[0];
538 memset(blk, 0, 64*
sizeof(*blk));
546 for (area = 0; area < 4; area++) {
547 bi->
prev[area] = prev;
550 int level = blk[zigzag_scan[i]];
552 if (level + 15 > 30
U) {
553 bi->
sign[i] = (level >> 31) & 1;
557 level = (
FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
568 for (bi->
cno = 0; max > classes[bi->
cno]; bi->
cno++);
576 for (area = 0; area < 4; area++) {
577 bi->
prev[area] = prev;
598 int i, j, k,
a, prev,
a2;
601 size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
604 for (i = 0; i < 5; i++) {
610 for (j = 0; j < 6; j++, b++) {
611 for (a = 0; a < 4; a++) {
644 }
while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
650 for (j = 0; j < 6 *5; j++, b++) {
652 for (k = b->
next[prev]; k < 64; k = b->next[k]) {
653 if (b->
mb[k] < a && b->
mb[k] > -a){
669 int mb_x, mb_y, c_offset, linesize, y_stride;
678 int qnos[5] = {15, 15, 15, 15, 15};
679 int* qnosp = &qnos[0];
682 enc_blk = &enc_blks[0];
683 for (mb_index = 0; mb_index < 5; mb_index++) {
689 (s->
sys->
height >= 720 && mb_y != 134)) {
715 for (j = 2; j; j--) {
722 for (i = 0; i < 8; i++) {
723 d = c_ptr + (linesize << 3);
724 b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
725 b[4] = d[0]; b[5] = d[1]; b[6] = d[2]; b[7] = d[3];
744 for (j=0; j<5*s->
sys->
bpm;) {
751 for (i=0; i<s->
sys->
bpm; i++, j++) {
755 put_sbits(&pbs[j], 9, ((enc_blks[j].
mb[0] >> 3) - 1024 + 2) >> 2);
756 put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
757 put_bits(&pbs[j], 2, enc_blks[j].cno);
765 for (i=0; i<s->
sys->
bpm; i++) {
766 if (enc_blks[start_mb+i].partial_bit_count)
773 for (j=0; j<5*s->
sys->
bpm; j++) {
774 if (enc_blks[j].partial_bit_count)
776 if (enc_blks[j].partial_bit_count)
780 for (j=0; j<5*s->
sys->
bpm; j++) {
789 memset(pbs[j].
buf + pos, 0xff, size - pos);
863 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
868 #if CONFIG_DVVIDEO_ENCODER
874 buf[1] = (seq_num << 4) |
884 if (syb_num == 0 || syb_num == 6) {
889 else if (syb_num == 11) {
910 memset(buf, 0xff, 80 * 6);
918 for (j = 0; j < 2; j++) {
920 for (k = 0; k < 6; k++)
921 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
926 for (j = 0; j < 3; j++) {
937 for (j = 0; j < 135; j++) {
939 memset(buf, 0xff, 80);
977 dv_format_frame(s, pkt->
data);
992 .encode2 = dvvideo_encode_frame,
998 #endif // CONFIG_DVVIDEO_ENCODER
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
#define AVERROR_PATCHWELCOME
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)
void(* get_pixels)(int16_t *block, const uint8_t *pixels, int line_size)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
int ff_dv_init_dynamic_tables(const DVprofile *d)
static av_cold int init(AVCodecContext *avctx)
const uint8_t ff_zigzag248_direct[64]
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
static const uint8_t dv_vlc_run[NB_DV_VLC]
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
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.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
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]
#define DV_PROFILE_IS_720p50(p)
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
static const int mb_area_start[5]
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
static void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
void(* idct_put[2])(uint8_t *dest, int line_size, int16_t *block)
static av_always_inline int dv_rl2vlc_size(int run, int l)
const char * name
Name of the codec implementation.
void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
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.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
const uint8_t * block_sizes
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define LOCAL_ALIGNED_8(t, v,...)
static int dv_work_pool_size(const DVprofile *d)
void(* fdct248)(int16_t *block)
#define DV_PROFILE_IS_1080i50(p)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t partial_bit_count
static const int vs_total_ac_bits
static int put_bits_left(PutBitContext *s)
uint16_t mb_coordinates[5]
#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
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Libavcodec external API header.
AVPixelFormat
Pixel format.
int flags
A combination of AV_PKT_FLAG values.
static int put_bits_count(PutBitContext *s)
common internal API header
const DVprofile * avpriv_dv_codec_profile(AVCodecContext *codec)
enum AVPictureType pict_type
Picture type of the frame.
#define DV_VLC_MAP_RUN_SIZE
int width
picture width / height.
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
static const uint8_t dv_vlc_len[NB_DV_VLC]
static void dv_vlc_map_tableinit(void)
static const int dv_weight_248[64]
void(* fdct[2])(int16_t *block)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const int remap[16]
static const uint8_t zigzag_scan[16+1]
static const uint8_t dv100_qstep[16]
main external API structure.
#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]
void(* get_pixels)(int16_t *block, const uint8_t *pixels, int line_size)
static const uint8_t dv_vlc_level[NB_DV_VLC]
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
AVFrame * coded_frame
the picture in the bitstream
av_cold int ff_dvvideo_init(AVCodecContext *avctx)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
#define DV_MAX_BPM
maximum number of blocks per macroblock in any DV format
static int weight(int i, int blen, int offset)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
static const uint8_t dv_quant_areas[4]
const int ff_dv_iweight_88[64]
const int ff_dv_iweight_1080_c[64]
const uint8_t ff_dv_quant_shifts[22][4]
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
common internal api header.
const uint8_t ff_zigzag_direct[64]
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
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.
int top_field_first
If the content is interlaced, is top field displayed first.
static void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot, uint16_t *tbl)
void(* fdct)(int16_t *block)
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]
#define LOCAL_ALIGNED_16(t, v,...)
static struct dv_vlc_pair dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE]
DVwork_chunk * work_chunks
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static av_always_inline PutBitContext * dv_encode_ac(EncBlockInfo *bi, PutBitContext *pb_pool, PutBitContext *pb_end)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.