69
static const uint8_t ff_default_chroma_qscale_table[32]={
70
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
71
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
74
const uint8_t ff_mpeg1_dc_scale_table[128]={
75
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
76
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82
static const uint8_t mpeg2_dc_scale_table1[128]={
83
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
84
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90
static const uint8_t mpeg2_dc_scale_table2[128]={
91
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
92
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98
static const uint8_t mpeg2_dc_scale_table3[128]={
99
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
100
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
102
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
103
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
106
const uint8_t * const ff_mpeg2_dc_scale_table[4]={
69
static const uint8_t ff_default_chroma_qscale_table[32] = {
70
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
71
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
72
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
75
const uint8_t ff_mpeg1_dc_scale_table[128] = {
76
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
77
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
81
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
83
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
84
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
87
static const uint8_t mpeg2_dc_scale_table1[128] = {
88
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
89
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
95
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
99
static const uint8_t mpeg2_dc_scale_table2[128] = {
100
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
101
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
111
static const uint8_t mpeg2_dc_scale_table3[128] = {
112
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
113
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
117
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
119
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
120
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
123
const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
107
124
ff_mpeg1_dc_scale_table,
108
125
mpeg2_dc_scale_table1,
109
126
mpeg2_dc_scale_table2,
255
* allocates a Picture
256
* The pixels are allocated/set by calling get_buffer() if shared=0
292
* Allocate a Picture.
293
* The pixels are allocated/set by calling get_buffer() if shared = 0
258
int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
259
const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
260
const int mb_array_size= s->mb_stride*s->mb_height;
261
const int b8_array_size= s->b8_stride*s->mb_height*2;
262
const int b4_array_size= s->b4_stride*s->mb_height*4;
295
int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
297
const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
299
// the + 1 is needed so memset(,,stride*height) does not sig11
301
const int mb_array_size = s->mb_stride * s->mb_height;
302
const int b8_array_size = s->b8_stride * s->mb_height * 2;
303
const int b4_array_size = s->b4_stride * s->mb_height * 4;
267
assert(pic->data[0]);
268
assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
269
pic->type= FF_BUFFER_TYPE_SHARED;
271
assert(!pic->data[0]);
308
assert(pic->f.data[0]);
309
assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
310
pic->f.type = FF_BUFFER_TYPE_SHARED;
312
assert(!pic->f.data[0]);
273
314
if (alloc_frame_buffer(s, pic) < 0)
276
s->linesize = pic->linesize[0];
277
s->uvlinesize= pic->linesize[1];
317
s->linesize = pic->f.linesize[0];
318
s->uvlinesize = pic->f.linesize[1];
280
if(pic->qscale_table==NULL){
321
if (pic->f.qscale_table == NULL) {
281
322
if (s->encoding) {
282
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var , mb_array_size * sizeof(int16_t) , fail)
283
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t) , fail)
284
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean , mb_array_size * sizeof(int8_t ) , fail)
323
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
324
mb_array_size * sizeof(int16_t), fail)
325
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
326
mb_array_size * sizeof(int16_t), fail)
327
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
328
mb_array_size * sizeof(int8_t ), fail)
287
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2, fail) //the +2 is for the slice end check
288
FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table , mb_array_size * sizeof(uint8_t) , fail)
289
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
290
pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
291
if(s->out_format == FMT_H264){
293
FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t), fail)
294
pic->motion_val[i]= pic->motion_val_base[i]+4;
295
FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
297
pic->motion_subsample_log2= 2;
298
}else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
300
FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
301
pic->motion_val[i]= pic->motion_val_base[i]+4;
302
FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
304
pic->motion_subsample_log2= 3;
306
if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
307
FF_ALLOCZ_OR_GOTO(s->avctx, pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6, fail)
309
pic->qstride= s->mb_stride;
310
FF_ALLOCZ_OR_GOTO(s->avctx, pic->pan_scan , 1 * sizeof(AVPanScan), fail)
331
FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
332
mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
333
FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
334
(big_mb_num + s->mb_stride) * sizeof(uint8_t),
336
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
337
(big_mb_num + s->mb_stride) * sizeof(uint32_t),
339
pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
340
pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
341
if (s->out_format == FMT_H264) {
342
for (i = 0; i < 2; i++) {
343
FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
344
2 * (b4_array_size + 4) * sizeof(int16_t),
346
pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
347
FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
348
4 * mb_array_size * sizeof(uint8_t), fail)
350
pic->f.motion_subsample_log2 = 2;
351
} else if (s->out_format == FMT_H263 || s->encoding ||
352
(s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
353
for (i = 0; i < 2; i++) {
354
FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
355
2 * (b8_array_size + 4) * sizeof(int16_t),
357
pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
358
FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
359
4 * mb_array_size * sizeof(uint8_t), fail)
361
pic->f.motion_subsample_log2 = 3;
363
if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
364
FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
365
64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
367
pic->f.qstride = s->mb_stride;
368
FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
369
1 * sizeof(AVPanScan), fail)
313
/* It might be nicer if the application would keep track of these
314
* but it would require an API change. */
315
memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
316
s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
317
if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
318
pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
322
fail: //for the FF_ALLOCZ_OR_GOTO macro
375
fail: // for the FF_ALLOCZ_OR_GOTO macro
324
377
free_frame_buffer(s, pic);
329
* deallocates a picture
382
* Deallocate a picture.
331
static void free_picture(MpegEncContext *s, Picture *pic){
384
static void free_picture(MpegEncContext *s, Picture *pic)
334
if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
388
if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
335
389
free_frame_buffer(s, pic);
338
392
av_freep(&pic->mb_var);
339
393
av_freep(&pic->mc_mb_var);
340
394
av_freep(&pic->mb_mean);
341
av_freep(&pic->mbskip_table);
342
av_freep(&pic->qscale_table);
395
av_freep(&pic->f.mbskip_table);
396
av_freep(&pic->qscale_table_base);
343
397
av_freep(&pic->mb_type_base);
344
av_freep(&pic->dct_coeff);
345
av_freep(&pic->pan_scan);
398
av_freep(&pic->f.dct_coeff);
399
av_freep(&pic->f.pan_scan);
400
pic->f.mb_type = NULL;
401
for (i = 0; i < 2; i++) {
348
402
av_freep(&pic->motion_val_base[i]);
349
av_freep(&pic->ref_index[i]);
403
av_freep(&pic->f.ref_index[i]);
352
if(pic->type == FF_BUFFER_TYPE_SHARED){
406
if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
407
for (i = 0; i < 4; i++) {
409
pic->f.data[i] = NULL;
361
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
415
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
362
417
int y_size = s->b8_stride * (2 * s->mb_height + 1);
363
418
int c_size = s->mb_stride * (s->mb_height + 1);
364
419
int yc_size = y_size + 2 * c_size;
367
// edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
368
FF_ALLOCZ_OR_GOTO(s->avctx, s->allocated_edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
369
s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
422
// edge emu needs blocksize + filter length - 1
423
// (= 17x17 for halfpel / 21x21 for h264)
424
FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
425
(s->width + 64) * 2 * 21 * 2, fail); // (width + edge + align)*interlaced*MBsize*tolerance
371
//FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
372
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
373
s->me.temp= s->me.scratchpad;
374
s->rd_scratchpad= s->me.scratchpad;
375
s->b_scratchpad= s->me.scratchpad;
376
s->obmc_scratchpad= s->me.scratchpad + 16;
427
// FIXME should be linesize instead of s->width * 2
428
// but that is not known before get_buffer()
429
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
430
(s->width + 64) * 4 * 16 * 2 * sizeof(uint8_t), fail)
431
s->me.temp = s->me.scratchpad;
432
s->rd_scratchpad = s->me.scratchpad;
433
s->b_scratchpad = s->me.scratchpad;
434
s->obmc_scratchpad = s->me.scratchpad + 16;
377
435
if (s->encoding) {
378
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map , ME_MAP_SIZE*sizeof(uint32_t), fail)
379
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
380
if(s->avctx->noise_reduction){
381
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
436
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
437
ME_MAP_SIZE * sizeof(uint32_t), fail)
438
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
439
ME_MAP_SIZE * sizeof(uint32_t), fail)
440
if (s->avctx->noise_reduction) {
441
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
442
2 * 64 * sizeof(int), fail)
384
FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
385
s->block= s->blocks[0];
445
FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
446
s->block = s->blocks[0];
448
for (i = 0; i < 12; i++) {
388
449
s->pblocks[i] = &s->block[i];
391
452
if (s->out_format == FMT_H263) {
393
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
454
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
455
yc_size * sizeof(int16_t) * 16, fail);
394
456
s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
395
457
s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
396
458
s->ac_val[2] = s->ac_val[1] + c_size;
575
658
av_cold int MPV_common_init(MpegEncContext *s)
577
int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
579
if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
660
int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
661
int nb_slices = (HAVE_THREADS &&
662
s->avctx->active_thread_type & FF_THREAD_SLICE) ?
663
s->avctx->thread_count : 1;
665
if (s->encoding && s->avctx->slices)
666
nb_slices = s->avctx->slices;
668
if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
580
669
s->mb_height = (s->height + 31) / 32 * 2;
581
670
else if (s->codec_id != CODEC_ID_H264)
582
671
s->mb_height = (s->height + 15) / 16;
584
if(s->avctx->pix_fmt == PIX_FMT_NONE){
585
av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
589
if((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
590
(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
591
av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
595
if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
598
dsputil_init(&s->dsp, s->avctx);
673
if (s->avctx->pix_fmt == PIX_FMT_NONE) {
674
av_log(s->avctx, AV_LOG_ERROR,
675
"decoding to PIX_FMT_NONE is not supported.\n");
679
if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
682
max_slices = FFMIN(MAX_THREADS, s->mb_height);
684
max_slices = MAX_THREADS;
685
av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
686
" reducing to %d\n", nb_slices, max_slices);
687
nb_slices = max_slices;
690
if ((s->width || s->height) &&
691
av_image_check_size(s->width, s->height, 0, s->avctx))
599
694
ff_dct_common_init(s);
601
s->flags= s->avctx->flags;
602
s->flags2= s->avctx->flags2;
696
s->flags = s->avctx->flags;
697
s->flags2 = s->avctx->flags2;
604
699
if (s->width && s->height) {
605
s->mb_width = (s->width + 15) / 16;
606
s->mb_stride = s->mb_width + 1;
607
s->b8_stride = s->mb_width*2 + 1;
608
s->b4_stride = s->mb_width*4 + 1;
609
mb_array_size= s->mb_height * s->mb_stride;
610
mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
700
s->mb_width = (s->width + 15) / 16;
701
s->mb_stride = s->mb_width + 1;
702
s->b8_stride = s->mb_width * 2 + 1;
703
s->b4_stride = s->mb_width * 4 + 1;
704
mb_array_size = s->mb_height * s->mb_stride;
705
mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
612
707
/* set chroma shifts */
613
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
614
&(s->chroma_y_shift) );
616
/* set default edge pos, will be overriden in decode_header if needed */
617
s->h_edge_pos= s->mb_width*16;
618
s->v_edge_pos= s->mb_height*16;
620
s->mb_num = s->mb_width * s->mb_height;
625
s->block_wrap[3]= s->b8_stride;
627
s->block_wrap[5]= s->mb_stride;
629
y_size = s->b8_stride * (2 * s->mb_height + 1);
630
c_size = s->mb_stride * (s->mb_height + 1);
631
yc_size = y_size + 2 * c_size;
708
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
711
/* set default edge pos, will be overriden
712
* in decode_header if needed */
713
s->h_edge_pos = s->mb_width * 16;
714
s->v_edge_pos = s->mb_height * 16;
716
s->mb_num = s->mb_width * s->mb_height;
721
s->block_wrap[3] = s->b8_stride;
723
s->block_wrap[5] = s->mb_stride;
725
y_size = s->b8_stride * (2 * s->mb_height + 1);
726
c_size = s->mb_stride * (s->mb_height + 1);
727
yc_size = y_size + 2 * c_size;
633
729
/* convert fourcc to upper case */
634
s->codec_tag = ff_toupper4(s->avctx->codec_tag);
636
s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
638
s->avctx->coded_frame= (AVFrame*)&s->current_picture;
640
FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
641
for(y=0; y<s->mb_height; y++){
642
for(x=0; x<s->mb_width; x++){
643
s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
646
s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
730
s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
732
s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
734
s->avctx->coded_frame = (AVFrame *)&s->current_picture;
736
FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
737
fail); // error ressilience code looks cleaner with this
738
for (y = 0; y < s->mb_height; y++)
739
for (x = 0; x < s->mb_width; x++)
740
s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
742
s->mb_index2xy[s->mb_height * s->mb_width] =
743
(s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
648
745
if (s->encoding) {
649
746
/* Allocate MV tables */
650
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
651
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
652
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
653
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
654
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
655
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
656
s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
657
s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
658
s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
659
s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
660
s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
661
s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
747
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
748
mv_table_size * 2 * sizeof(int16_t), fail);
749
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
750
mv_table_size * 2 * sizeof(int16_t), fail);
751
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
752
mv_table_size * 2 * sizeof(int16_t), fail);
753
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
754
mv_table_size * 2 * sizeof(int16_t), fail);
755
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
756
mv_table_size * 2 * sizeof(int16_t), fail);
757
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
758
mv_table_size * 2 * sizeof(int16_t), fail);
759
s->p_mv_table = s->p_mv_table_base +
761
s->b_forw_mv_table = s->b_forw_mv_table_base +
763
s->b_back_mv_table = s->b_back_mv_table_base +
765
s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
767
s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
769
s->b_direct_mv_table = s->b_direct_mv_table_base +
663
if(s->msmpeg4_version){
664
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
772
if (s->msmpeg4_version) {
773
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
774
2 * 2 * (MAX_LEVEL + 1) *
775
(MAX_RUN + 1) * 2 * sizeof(int), fail);
666
777
FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
668
779
/* Allocate MB type table */
669
FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
671
FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
673
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
674
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
675
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
676
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
677
FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
678
FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
680
if(s->avctx->noise_reduction){
681
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
780
FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
781
sizeof(uint16_t), fail); // needed for encoding
783
FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
786
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,
787
64 * 32 * sizeof(int), fail);
788
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,
789
64 * 32 * sizeof(int), fail);
790
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,
791
64 * 32 * 2 * sizeof(uint16_t), fail);
792
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,
793
64 * 32 * 2 * sizeof(uint16_t), fail);
794
FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
795
MAX_PICTURE_COUNT * sizeof(Picture *), fail);
796
FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
797
MAX_PICTURE_COUNT * sizeof(Picture *), fail);
799
if (s->avctx->noise_reduction) {
800
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
801
2 * 64 * sizeof(uint16_t), fail);
686
806
s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
687
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
688
for(i = 0; i < s->picture_count; i++) {
689
avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
807
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
808
s->picture_count * sizeof(Picture), fail);
809
for (i = 0; i < s->picture_count; i++) {
810
avcodec_get_frame_defaults((AVFrame *) &s->picture[i]);
692
813
if (s->width && s->height) {
693
FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
814
FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
815
mb_array_size * sizeof(uint8_t), fail);
695
if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
817
if (s->codec_id == CODEC_ID_MPEG4 ||
818
(s->flags & CODEC_FLAG_INTERLACED_ME)) {
696
819
/* interlaced direct mode decoding tables */
820
for (i = 0; i < 2; i++) {
701
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
702
s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
822
for (j = 0; j < 2; j++) {
823
for (k = 0; k < 2; k++) {
824
FF_ALLOCZ_OR_GOTO(s->avctx,
825
s->b_field_mv_table_base[i][j][k],
826
mv_table_size * 2 * sizeof(int16_t),
828
s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
704
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
705
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
706
s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
831
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
832
mb_array_size * 2 * sizeof(uint8_t),
834
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
835
mv_table_size * 2 * sizeof(int16_t),
837
s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
708
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
840
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
841
mb_array_size * 2 * sizeof(uint8_t),
711
845
if (s->out_format == FMT_H263) {
713
847
FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
714
s->coded_block= s->coded_block_base + s->b8_stride + 1;
848
s->coded_block = s->coded_block_base + s->b8_stride + 1;
716
850
/* cbp, ac_pred, pred_dir */
717
FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
718
FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
851
FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
852
mb_array_size * sizeof(uint8_t), fail);
853
FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
854
mb_array_size * sizeof(uint8_t), fail);
721
857
if (s->h263_pred || s->h263_plus || !s->encoding) {
723
//MN: we need these for error resilience of intra-frames
724
FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
859
// MN: we need these for error resilience of intra-frames
860
FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
861
yc_size * sizeof(int16_t), fail);
725
862
s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
726
863
s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
727
864
s->dc_val[2] = s->dc_val[1] + c_size;
728
for(i=0;i<yc_size;i++)
865
for (i = 0; i < yc_size; i++)
729
866
s->dc_val_base[i] = 1024;
1028
1167
s->mb_skipped = 0;
1030
assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1169
assert(s->last_picture_ptr == NULL || s->out_format != FMT_H264 ||
1170
s->codec_id == CODEC_ID_SVQ3);
1032
/* mark&release old frames */
1033
if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1034
if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1035
free_frame_buffer(s, s->last_picture_ptr);
1172
/* mark & release old frames */
1173
if (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3) {
1174
if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1175
s->last_picture_ptr != s->next_picture_ptr &&
1176
s->last_picture_ptr->f.data[0]) {
1177
if (s->last_picture_ptr->owner2 == s)
1178
free_frame_buffer(s, s->last_picture_ptr);
1037
1181
/* release forgotten pictures */
1038
/* if(mpeg124/h263) */
1040
for(i=0; i<s->picture_count; i++){
1041
if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1042
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1182
/* if (mpeg124/h263) */
1184
for (i = 0; i < s->picture_count; i++) {
1185
if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1186
&s->picture[i] != s->last_picture_ptr &&
1187
&s->picture[i] != s->next_picture_ptr &&
1188
s->picture[i].f.reference) {
1189
if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1190
av_log(avctx, AV_LOG_ERROR,
1191
"releasing zombie picture\n");
1043
1192
free_frame_buffer(s, &s->picture[i]);
1051
1199
ff_release_unused_pictures(s, 1);
1053
if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1054
pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1056
i= ff_find_unused_picture(s, 0);
1057
pic= &s->picture[i];
1201
if (s->current_picture_ptr &&
1202
s->current_picture_ptr->f.data[0] == NULL) {
1203
// we already have a unused image
1204
// (maybe it was set before reading the header)
1205
pic = s->current_picture_ptr;
1207
i = ff_find_unused_picture(s, 0);
1208
pic = &s->picture[i];
1211
pic->f.reference = 0;
1062
1213
if (s->codec_id == CODEC_ID_H264)
1063
pic->reference = s->picture_structure;
1214
pic->f.reference = s->picture_structure;
1064
1215
else if (s->pict_type != AV_PICTURE_TYPE_B)
1216
pic->f.reference = 3;
1068
pic->coded_picture_number= s->coded_picture_number++;
1219
pic->f.coded_picture_number = s->coded_picture_number++;
1070
if(ff_alloc_picture(s, pic, 0) < 0)
1221
if (ff_alloc_picture(s, pic, 0) < 0)
1073
s->current_picture_ptr= pic;
1074
//FIXME use only the vars from current_pic
1075
s->current_picture_ptr->top_field_first= s->top_field_first;
1076
if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1077
if(s->picture_structure != PICT_FRAME)
1078
s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1224
s->current_picture_ptr = pic;
1225
// FIXME use only the vars from current_pic
1226
s->current_picture_ptr->f.top_field_first = s->top_field_first;
1227
if (s->codec_id == CODEC_ID_MPEG1VIDEO ||
1228
s->codec_id == CODEC_ID_MPEG2VIDEO) {
1229
if (s->picture_structure != PICT_FRAME)
1230
s->current_picture_ptr->f.top_field_first =
1231
(s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1080
s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1081
s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1233
s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1234
!s->progressive_sequence;
1235
s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1084
s->current_picture_ptr->pict_type= s->pict_type;
1085
// if(s->flags && CODEC_FLAG_QSCALE)
1086
// s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1087
s->current_picture_ptr->key_frame= s->pict_type == AV_PICTURE_TYPE_I;
1238
s->current_picture_ptr->f.pict_type = s->pict_type;
1239
// if (s->flags && CODEC_FLAG_QSCALE)
1240
// s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1241
s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1089
1243
ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1091
1245
if (s->pict_type != AV_PICTURE_TYPE_B) {
1092
s->last_picture_ptr= s->next_picture_ptr;
1094
s->next_picture_ptr= s->current_picture_ptr;
1246
s->last_picture_ptr = s->next_picture_ptr;
1248
s->next_picture_ptr = s->current_picture_ptr;
1096
/* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1097
s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1098
s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1099
s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1100
s->pict_type, s->dropable);*/
1250
/* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1251
s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1252
s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1253
s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1254
s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1255
s->pict_type, s->dropable); */
1102
if(s->codec_id != CODEC_ID_H264){
1103
if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) &&
1104
(s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1257
if (s->codec_id != CODEC_ID_H264) {
1258
if ((s->last_picture_ptr == NULL ||
1259
s->last_picture_ptr->f.data[0] == NULL) &&
1260
(s->pict_type != AV_PICTURE_TYPE_I ||
1261
s->picture_structure != PICT_FRAME)) {
1105
1262
if (s->pict_type != AV_PICTURE_TYPE_I)
1106
av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1263
av_log(avctx, AV_LOG_ERROR,
1264
"warning: first frame is no keyframe\n");
1107
1265
else if (s->picture_structure != PICT_FRAME)
1108
av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1110
/* Allocate a dummy frame */
1111
i= ff_find_unused_picture(s, 0);
1112
s->last_picture_ptr= &s->picture[i];
1113
if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1115
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1116
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1118
if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==AV_PICTURE_TYPE_B){
1119
/* Allocate a dummy frame */
1120
i= ff_find_unused_picture(s, 0);
1121
s->next_picture_ptr= &s->picture[i];
1122
if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1124
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1125
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1129
if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1130
if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1132
assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1134
if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1266
av_log(avctx, AV_LOG_INFO,
1267
"allocate dummy last picture for field based first keyframe\n");
1269
/* Allocate a dummy frame */
1270
i = ff_find_unused_picture(s, 0);
1271
s->last_picture_ptr = &s->picture[i];
1272
if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1274
ff_thread_report_progress((AVFrame *) s->last_picture_ptr,
1276
ff_thread_report_progress((AVFrame *) s->last_picture_ptr,
1279
if ((s->next_picture_ptr == NULL ||
1280
s->next_picture_ptr->f.data[0] == NULL) &&
1281
s->pict_type == AV_PICTURE_TYPE_B) {
1282
/* Allocate a dummy frame */
1283
i = ff_find_unused_picture(s, 0);
1284
s->next_picture_ptr = &s->picture[i];
1285
if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1287
ff_thread_report_progress((AVFrame *) s->next_picture_ptr,
1289
ff_thread_report_progress((AVFrame *) s->next_picture_ptr,
1294
if (s->last_picture_ptr)
1295
ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1296
if (s->next_picture_ptr)
1297
ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1299
if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1300
(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)) {
1301
if (s->next_picture_ptr)
1302
s->next_picture_ptr->owner2 = s;
1303
if (s->last_picture_ptr)
1304
s->last_picture_ptr->owner2 = s;
1307
assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1308
s->last_picture_ptr->f.data[0]));
1310
if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1137
if(s->picture_structure == PICT_BOTTOM_FIELD){
1138
s->current_picture.data[i] += s->current_picture.linesize[i];
1312
for (i = 0; i < 4; i++) {
1313
if (s->picture_structure == PICT_BOTTOM_FIELD) {
1314
s->current_picture.f.data[i] +=
1315
s->current_picture.f.linesize[i];
1140
s->current_picture.linesize[i] *= 2;
1141
s->last_picture.linesize[i] *=2;
1142
s->next_picture.linesize[i] *=2;
1317
s->current_picture.f.linesize[i] *= 2;
1318
s->last_picture.f.linesize[i] *= 2;
1319
s->next_picture.f.linesize[i] *= 2;
1146
s->error_recognition= avctx->error_recognition;
1323
s->err_recognition = avctx->err_recognition;
1148
/* set dequantizer, we can't do it during init as it might change for mpeg4
1149
and we can't do it in the header decode as init is not called for mpeg4 there yet */
1150
if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1325
/* set dequantizer, we can't do it during init as
1326
* it might change for mpeg4 and we can't do it in the header
1327
* decode as init is not called for mpeg4 there yet */
1328
if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1151
1329
s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1152
1330
s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1153
}else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1331
} else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1154
1332
s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1155
1333
s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1157
1335
s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1158
1336
s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1161
if(s->dct_error_sum){
1339
if (s->dct_error_sum) {
1162
1340
assert(s->avctx->noise_reduction && s->encoding);
1164
1341
update_noise_reduction(s);
1167
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1344
if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1168
1345
return ff_xvmc_field_start(s, avctx);
1173
/* generic function for encode/decode called after a frame has been coded/decoded */
1350
/* generic function for encode/decode called after a
1351
* frame has been coded/decoded. */
1174
1352
void MPV_frame_end(MpegEncContext *s)
1177
1355
/* redraw edges for the frame if decoding didn't complete */
1178
//just to make sure that all data is rendered.
1179
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1356
// just to make sure that all data is rendered.
1357
if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1180
1358
ff_xvmc_field_end(s);
1181
}else if((s->error_count || s->encoding)
1182
&& !s->avctx->hwaccel
1183
&& !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1184
&& s->unrestricted_mv
1185
&& s->current_picture.reference
1187
&& !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1188
int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1189
int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1190
s->dsp.draw_edges(s->current_picture.data[0], s->linesize ,
1191
s->h_edge_pos , s->v_edge_pos,
1192
EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1193
s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize,
1194
s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1195
EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1196
s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize,
1197
s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1198
EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1359
} else if ((s->error_count || s->encoding) &&
1360
!s->avctx->hwaccel &&
1361
!(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1362
s->unrestricted_mv &&
1363
s->current_picture.f.reference &&
1365
!(s->flags & CODEC_FLAG_EMU_EDGE)) {
1366
int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1367
int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1368
s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1369
s->h_edge_pos, s->v_edge_pos,
1370
EDGE_WIDTH, EDGE_WIDTH,
1371
EDGE_TOP | EDGE_BOTTOM);
1372
s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1373
s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1374
EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1375
EDGE_TOP | EDGE_BOTTOM);
1376
s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1377
s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1378
EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1379
EDGE_TOP | EDGE_BOTTOM);
1203
s->last_pict_type = s->pict_type;
1204
s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1205
if(s->pict_type!=AV_PICTURE_TYPE_B){
1206
s->last_non_b_pict_type= s->pict_type;
1384
s->last_pict_type = s->pict_type;
1385
s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1386
if (s->pict_type!= AV_PICTURE_TYPE_B) {
1387
s->last_non_b_pict_type = s->pict_type;
1209
/* copy back current_picture variables */
1210
for(i=0; i<MAX_PICTURE_COUNT; i++){
1211
if(s->picture[i].data[0] == s->current_picture.data[0]){
1212
s->picture[i]= s->current_picture;
1390
/* copy back current_picture variables */
1391
for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1392
if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1393
s->picture[i] = s->current_picture;
1216
assert(i<MAX_PICTURE_COUNT);
1397
assert(i < MAX_PICTURE_COUNT);
1220
1401
/* release non-reference frames */
1221
for(i=0; i<s->picture_count; i++){
1222
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1402
for (i = 0; i < s->picture_count; i++) {
1403
if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1404
/* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1223
1405
free_frame_buffer(s, &s->picture[i]);
1227
1409
// clear copies, to avoid confusion
1229
memset(&s->last_picture, 0, sizeof(Picture));
1230
memset(&s->next_picture, 0, sizeof(Picture));
1411
memset(&s->last_picture, 0, sizeof(Picture));
1412
memset(&s->next_picture, 0, sizeof(Picture));
1231
1413
memset(&s->current_picture, 0, sizeof(Picture));
1233
s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1415
s->avctx->coded_frame = (AVFrame *) s->current_picture_ptr;
1235
if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1236
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1417
if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1418
ff_thread_report_progress((AVFrame *) s->current_picture_ptr,
1419
s->mb_height - 1, 0);
1241
* draws an line from (ex, ey) -> (sx, sy).
1424
* Draw a line from (ex, ey) -> (sx, sy).
1242
1425
* @param w width of the image
1243
1426
* @param h height of the image
1244
1427
* @param stride stride/linesize of the image
1245
1428
* @param color color of the arrow
1247
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1430
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1431
int w, int h, int stride, int color)
1248
1433
int x, y, fr, f;
1250
sx= av_clip(sx, 0, w-1);
1251
sy= av_clip(sy, 0, h-1);
1252
ex= av_clip(ex, 0, w-1);
1253
ey= av_clip(ey, 0, h-1);
1255
buf[sy*stride + sx]+= color;
1257
if(FFABS(ex - sx) > FFABS(ey - sy)){
1259
FFSWAP(int, sx, ex);
1260
FFSWAP(int, sy, ey);
1262
buf+= sx + sy*stride;
1264
f= ((ey-sy)<<16)/ex;
1265
for(x= 0; x <= ex; x++){
1268
buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1269
buf[(y+1)*stride + x]+= (color* fr )>>16;
1273
FFSWAP(int, sx, ex);
1274
FFSWAP(int, sy, ey);
1276
buf+= sx + sy*stride;
1278
if(ey) f= ((ex-sx)<<16)/ey;
1280
for(y= 0; y <= ey; y++){
1283
buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1284
buf[y*stride + x+1]+= (color* fr )>>16;
1435
sx = av_clip(sx, 0, w - 1);
1436
sy = av_clip(sy, 0, h - 1);
1437
ex = av_clip(ex, 0, w - 1);
1438
ey = av_clip(ey, 0, h - 1);
1440
buf[sy * stride + sx] += color;
1442
if (FFABS(ex - sx) > FFABS(ey - sy)) {
1444
FFSWAP(int, sx, ex);
1445
FFSWAP(int, sy, ey);
1447
buf += sx + sy * stride;
1449
f = ((ey - sy) << 16) / ex;
1450
for (x = 0; x = ex; x++) {
1452
fr = (x * f) & 0xFFFF;
1453
buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1454
buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1458
FFSWAP(int, sx, ex);
1459
FFSWAP(int, sy, ey);
1461
buf += sx + sy * stride;
1464
f = ((ex - sx) << 16) / ey;
1467
for (y = 0; y = ey; y++) {
1469
fr = (y * f) & 0xFFFF;
1470
buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1471
buf[y * stride + x + 1] += (color * fr ) >> 16;
1290
* draws an arrow from (ex, ey) -> (sx, sy).
1477
* Draw an arrow from (ex, ey) -> (sx, sy).
1291
1478
* @param w width of the image
1292
1479
* @param h height of the image
1293
1480
* @param stride stride/linesize of the image
1294
1481
* @param color color of the arrow
1296
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1483
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1484
int ey, int w, int h, int stride, int color)
1299
sx= av_clip(sx, -100, w+100);
1300
sy= av_clip(sy, -100, h+100);
1301
ex= av_clip(ex, -100, w+100);
1302
ey= av_clip(ey, -100, h+100);
1307
if(dx*dx + dy*dy > 3*3){
1310
int length= ff_sqrt((rx*rx + ry*ry)<<8);
1312
//FIXME subpixel accuracy
1313
rx= ROUNDED_DIV(rx*3<<4, length);
1314
ry= ROUNDED_DIV(ry*3<<4, length);
1488
sx = av_clip(sx, -100, w + 100);
1489
sy = av_clip(sy, -100, h + 100);
1490
ex = av_clip(ex, -100, w + 100);
1491
ey = av_clip(ey, -100, h + 100);
1496
if (dx * dx + dy * dy > 3 * 3) {
1499
int length = ff_sqrt((rx * rx + ry * ry) << 8);
1501
// FIXME subpixel accuracy
1502
rx = ROUNDED_DIV(rx * 3 << 4, length);
1503
ry = ROUNDED_DIV(ry * 3 << 4, length);
1316
1505
draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1317
1506
draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1323
* prints debuging info for the given picture.
1512
* Print debugging info for the given picture.
1325
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1327
if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1329
if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1514
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1516
if (s->avctx->hwaccel || !pict || !pict->mb_type)
1519
if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1332
1522
av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1333
1523
switch (pict->pict_type) {
1334
case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1335
case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1336
case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1337
case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1338
case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1339
case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1524
case AV_PICTURE_TYPE_I:
1525
av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1527
case AV_PICTURE_TYPE_P:
1528
av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1530
case AV_PICTURE_TYPE_B:
1531
av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1533
case AV_PICTURE_TYPE_S:
1534
av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1536
case AV_PICTURE_TYPE_SI:
1537
av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1539
case AV_PICTURE_TYPE_SP:
1540
av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1341
for(y=0; y<s->mb_height; y++){
1342
for(x=0; x<s->mb_width; x++){
1343
if(s->avctx->debug&FF_DEBUG_SKIP){
1344
int count= s->mbskip_table[x + y*s->mb_stride];
1345
if(count>9) count=9;
1543
for (y = 0; y < s->mb_height; y++) {
1544
for (x = 0; x < s->mb_width; x++) {
1545
if (s->avctx->debug & FF_DEBUG_SKIP) {
1546
int count = s->mbskip_table[x + y * s->mb_stride];
1346
1549
av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1348
if(s->avctx->debug&FF_DEBUG_QP){
1349
av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1551
if (s->avctx->debug & FF_DEBUG_QP) {
1552
av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1553
pict->qscale_table[x + y * s->mb_stride]);
1351
if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1352
int mb_type= pict->mb_type[x + y*s->mb_stride];
1353
//Type & MV direction
1555
if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1556
int mb_type = pict->mb_type[x + y * s->mb_stride];
1557
// Type & MV direction
1558
if (IS_PCM(mb_type))
1355
1559
av_log(s->avctx, AV_LOG_DEBUG, "P");
1356
else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1560
else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1357
1561
av_log(s->avctx, AV_LOG_DEBUG, "A");
1358
else if(IS_INTRA4x4(mb_type))
1562
else if (IS_INTRA4x4(mb_type))
1359
1563
av_log(s->avctx, AV_LOG_DEBUG, "i");
1360
else if(IS_INTRA16x16(mb_type))
1564
else if (IS_INTRA16x16(mb_type))
1361
1565
av_log(s->avctx, AV_LOG_DEBUG, "I");
1362
else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1566
else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1363
1567
av_log(s->avctx, AV_LOG_DEBUG, "d");
1364
else if(IS_DIRECT(mb_type))
1568
else if (IS_DIRECT(mb_type))
1365
1569
av_log(s->avctx, AV_LOG_DEBUG, "D");
1366
else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1570
else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1367
1571
av_log(s->avctx, AV_LOG_DEBUG, "g");
1368
else if(IS_GMC(mb_type))
1572
else if (IS_GMC(mb_type))
1369
1573
av_log(s->avctx, AV_LOG_DEBUG, "G");
1370
else if(IS_SKIP(mb_type))
1574
else if (IS_SKIP(mb_type))
1371
1575
av_log(s->avctx, AV_LOG_DEBUG, "S");
1372
else if(!USES_LIST(mb_type, 1))
1576
else if (!USES_LIST(mb_type, 1))
1373
1577
av_log(s->avctx, AV_LOG_DEBUG, ">");
1374
else if(!USES_LIST(mb_type, 0))
1578
else if (!USES_LIST(mb_type, 0))
1375
1579
av_log(s->avctx, AV_LOG_DEBUG, "<");
1377
1581
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1378
1582
av_log(s->avctx, AV_LOG_DEBUG, "X");
1586
if (IS_8X8(mb_type))
1383
1587
av_log(s->avctx, AV_LOG_DEBUG, "+");
1384
else if(IS_16X8(mb_type))
1588
else if (IS_16X8(mb_type))
1385
1589
av_log(s->avctx, AV_LOG_DEBUG, "-");
1386
else if(IS_8X16(mb_type))
1590
else if (IS_8X16(mb_type))
1387
1591
av_log(s->avctx, AV_LOG_DEBUG, "|");
1388
else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1592
else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1389
1593
av_log(s->avctx, AV_LOG_DEBUG, " ");
1391
1595
av_log(s->avctx, AV_LOG_DEBUG, "?");
1394
if(IS_INTERLACED(mb_type))
1598
if (IS_INTERLACED(mb_type))
1395
1599
av_log(s->avctx, AV_LOG_DEBUG, "=");
1397
1601
av_log(s->avctx, AV_LOG_DEBUG, " ");
1399
// av_log(s->avctx, AV_LOG_DEBUG, " ");
1603
// av_log(s->avctx, AV_LOG_DEBUG, " ");
1401
1605
av_log(s->avctx, AV_LOG_DEBUG, "\n");
1405
if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1406
const int shift= 1 + s->quarter_sample;
1609
if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1610
(s->avctx->debug_mv)) {
1611
const int shift = 1 + s->quarter_sample;
1410
1615
int h_chroma_shift, v_chroma_shift, block_height;
1411
const int width = s->avctx->width;
1412
const int height= s->avctx->height;
1413
const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1414
const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1415
s->low_delay=0; //needed to see the vectors without trashing the buffers
1616
const int width = s->avctx->width;
1617
const int height = s->avctx->height;
1618
const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1619
const int mv_stride = (s->mb_width << mv_sample_log2) +
1620
(s->codec_id == CODEC_ID_H264 ? 0 : 1);
1621
s->low_delay = 0; // needed to see the vectors without trashing the buffers
1417
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1419
memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1420
pict->data[i]= s->visualization_buffer[i];
1623
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1624
&h_chroma_shift, &v_chroma_shift);
1625
for (i = 0; i < 3; i++) {
1626
memcpy(s->visualization_buffer[i], pict->data[i],
1627
(i == 0) ? pict->linesize[i] * height:
1628
pict->linesize[i] * height >> v_chroma_shift);
1629
pict->data[i] = s->visualization_buffer[i];
1422
pict->type= FF_BUFFER_TYPE_COPY;
1424
block_height = 16>>v_chroma_shift;
1631
pict->type = FF_BUFFER_TYPE_COPY;
1632
ptr = pict->data[0];
1633
block_height = 16 >> v_chroma_shift;
1426
for(mb_y=0; mb_y<s->mb_height; mb_y++){
1635
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1428
for(mb_x=0; mb_x<s->mb_width; mb_x++){
1429
const int mb_index= mb_x + mb_y*s->mb_stride;
1430
if((s->avctx->debug_mv) && pict->motion_val){
1432
for(type=0; type<3; type++){
1435
case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1439
case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1443
case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1448
if(!USES_LIST(pict->mb_type[mb_index], direction))
1451
if(IS_8X8(pict->mb_type[mb_index])){
1454
int sx= mb_x*16 + 4 + 8*(i&1);
1455
int sy= mb_y*16 + 4 + 8*(i>>1);
1456
int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1457
int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1458
int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1459
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1461
}else if(IS_16X8(pict->mb_type[mb_index])){
1465
int sy=mb_y*16 + 4 + 8*i;
1466
int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1467
int mx=(pict->motion_val[direction][xy][0]>>shift);
1468
int my=(pict->motion_val[direction][xy][1]>>shift);
1470
if(IS_INTERLACED(pict->mb_type[mb_index]))
1473
draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1475
}else if(IS_8X16(pict->mb_type[mb_index])){
1478
int sx=mb_x*16 + 4 + 8*i;
1480
int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1481
int mx=(pict->motion_val[direction][xy][0]>>shift);
1482
int my=(pict->motion_val[direction][xy][1]>>shift);
1484
if(IS_INTERLACED(pict->mb_type[mb_index]))
1487
draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1490
int sx= mb_x*16 + 8;
1491
int sy= mb_y*16 + 8;
1492
int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1493
int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1494
int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1495
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1637
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1638
const int mb_index = mb_x + mb_y * s->mb_stride;
1639
if ((s->avctx->debug_mv) && pict->motion_val) {
1641
for (type = 0; type < 3; type++) {
1645
if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1646
(pict->pict_type!= AV_PICTURE_TYPE_P))
1651
if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1652
(pict->pict_type!= AV_PICTURE_TYPE_B))
1657
if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1658
(pict->pict_type!= AV_PICTURE_TYPE_B))
1663
if (!USES_LIST(pict->mb_type[mb_index], direction))
1666
if (IS_8X8(pict->mb_type[mb_index])) {
1668
for (i = 0; i < 4; i++) {
1669
int sx = mb_x * 16 + 4 + 8 * (i & 1);
1670
int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1671
int xy = (mb_x * 2 + (i & 1) +
1672
(mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1673
int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1674
int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1675
draw_arrow(ptr, sx, sy, mx, my, width,
1676
height, s->linesize, 100);
1678
} else if (IS_16X8(pict->mb_type[mb_index])) {
1680
for (i = 0; i < 2; i++) {
1681
int sx = mb_x * 16 + 8;
1682
int sy = mb_y * 16 + 4 + 8 * i;
1683
int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1684
int mx = (pict->motion_val[direction][xy][0] >> shift);
1685
int my = (pict->motion_val[direction][xy][1] >> shift);
1687
if (IS_INTERLACED(pict->mb_type[mb_index]))
1690
draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1691
height, s->linesize, 100);
1693
} else if (IS_8X16(pict->mb_type[mb_index])) {
1695
for (i = 0; i < 2; i++) {
1696
int sx = mb_x * 16 + 4 + 8 * i;
1697
int sy = mb_y * 16 + 8;
1698
int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1699
int mx = pict->motion_val[direction][xy][0] >> shift;
1700
int my = pict->motion_val[direction][xy][1] >> shift;
1702
if (IS_INTERLACED(pict->mb_type[mb_index]))
1705
draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1706
height, s->linesize, 100);
1709
int sx = mb_x * 16 + 8;
1710
int sy = mb_y * 16 + 8;
1711
int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1712
int mx = pict->motion_val[direction][xy][0] >> shift + sx;
1713
int my = pict->motion_val[direction][xy][1] >> shift + sy;
1714
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1499
if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1500
uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1718
if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1719
uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1720
0x0101010101010101ULL;
1502
for(y=0; y<block_height; y++){
1503
*(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1504
*(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1722
for (y = 0; y < block_height; y++) {
1723
*(uint64_t *)(pict->data[1] + 8 * mb_x +
1724
(block_height * mb_y + y) *
1725
pict->linesize[1]) = c;
1726
*(uint64_t *)(pict->data[2] + 8 * mb_x +
1727
(block_height * mb_y + y) *
1728
pict->linesize[2]) = c;
1507
if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1508
int mb_type= pict->mb_type[mb_index];
1731
if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1733
int mb_type = pict->mb_type[mb_index];
1511
#define COLOR(theta, r)\
1512
u= (int)(128 + r*cos(theta*3.141592/180));\
1513
v= (int)(128 + r*sin(theta*3.141592/180));
1517
if(IS_PCM(mb_type)){
1519
}else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1521
}else if(IS_INTRA4x4(mb_type)){
1523
}else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1525
}else if(IS_DIRECT(mb_type)){
1527
}else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1529
}else if(IS_GMC(mb_type)){
1531
}else if(IS_SKIP(mb_type)){
1533
}else if(!USES_LIST(mb_type, 1)){
1535
}else if(!USES_LIST(mb_type, 0)){
1736
#define COLOR(theta, r) \
1737
u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1738
v = (int)(128 + r * sin(theta * 3.141592 / 180));
1742
if (IS_PCM(mb_type)) {
1744
} else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1745
IS_INTRA16x16(mb_type)) {
1747
} else if (IS_INTRA4x4(mb_type)) {
1749
} else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1751
} else if (IS_DIRECT(mb_type)) {
1753
} else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1755
} else if (IS_GMC(mb_type)) {
1757
} else if (IS_SKIP(mb_type)) {
1759
} else if (!USES_LIST(mb_type, 1)) {
1761
} else if (!USES_LIST(mb_type, 0)) {
1538
1764
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1542
u*= 0x0101010101010101ULL;
1543
v*= 0x0101010101010101ULL;
1544
for(y=0; y<block_height; y++){
1545
*(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1546
*(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1768
u *= 0x0101010101010101ULL;
1769
v *= 0x0101010101010101ULL;
1770
for (y = 0; y < block_height; y++) {
1771
*(uint64_t *)(pict->data[1] + 8 * mb_x +
1772
(block_height * mb_y + y) * pict->linesize[1]) = u;
1773
*(uint64_t *)(pict->data[2] + 8 * mb_x +
1774
(block_height * mb_y + y) * pict->linesize[2]) = v;
1550
if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1551
*(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1552
*(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1554
if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1556
pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1558
if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1559
int dm= 1 << (mv_sample_log2-2);
1561
int sx= mb_x*16 + 8*(i&1);
1562
int sy= mb_y*16 + 8*(i>>1);
1563
int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1565
int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1566
if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1568
pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1569
if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1570
*(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1778
if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1779
*(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1780
(16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1781
*(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1782
(16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1784
if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1785
for (y = 0; y < 16; y++)
1786
pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1787
pict->linesize[0]] ^= 0x80;
1789
if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1790
int dm = 1 << (mv_sample_log2 - 2);
1791
for (i = 0; i < 4; i++) {
1792
int sx = mb_x * 16 + 8 * (i & 1);
1793
int sy = mb_y * 16 + 8 * (i >> 1);
1794
int xy = (mb_x * 2 + (i & 1) +
1795
(mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1797
int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1798
if (mv[0] != mv[dm] ||
1799
mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1800
for (y = 0; y < 8; y++)
1801
pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1802
if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1803
*(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1804
pict->linesize[0]) ^= 0x8080808080808080ULL;
1574
if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1808
if (IS_INTERLACED(mb_type) &&
1809
s->codec_id == CODEC_ID_H264) {
1578
s->mbskip_table[mb_index]=0;
1813
s->mbskip_table[mb_index] = 0;
1584
1819
static inline int hpel_motion_lowres(MpegEncContext *s,
1585
uint8_t *dest, uint8_t *src,
1586
int field_based, int field_select,
1587
int src_x, int src_y,
1588
int width, int height, int stride,
1589
int h_edge_pos, int v_edge_pos,
1590
int w, int h, h264_chroma_mc_func *pix_op,
1591
int motion_x, int motion_y)
1820
uint8_t *dest, uint8_t *src,
1821
int field_based, int field_select,
1822
int src_x, int src_y,
1823
int width, int height, int stride,
1824
int h_edge_pos, int v_edge_pos,
1825
int w, int h, h264_chroma_mc_func *pix_op,
1826
int motion_x, int motion_y)
1593
const int lowres= s->avctx->lowres;
1594
const int op_index= FFMIN(lowres, 2);
1595
const int s_mask= (2<<lowres)-1;
1828
const int lowres = s->avctx->lowres;
1829
const int op_index = FFMIN(lowres, 2);
1830
const int s_mask = (2 << lowres) - 1;
1599
if(s->quarter_sample){
1604
sx= motion_x & s_mask;
1605
sy= motion_y & s_mask;
1606
src_x += motion_x >> (lowres+1);
1607
src_y += motion_y >> (lowres+1);
1609
src += src_y * stride + src_x;
1611
if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1612
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1613
s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1614
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1615
src= s->edge_emu_buffer;
1619
sx= (sx << 2) >> lowres;
1620
sy= (sy << 2) >> lowres;
1834
if (s->quarter_sample) {
1839
sx = motion_x & s_mask;
1840
sy = motion_y & s_mask;
1841
src_x += motion_x >> lowres + 1;
1842
src_y += motion_y >> lowres + 1;
1844
src += src_y * stride + src_x;
1846
if ((unsigned)src_x > h_edge_pos - (!!sx) - w ||
1847
(unsigned)src_y > (v_edge_pos >> field_based) - (!!sy) - h) {
1848
s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1849
(h + 1) << field_based, src_x,
1850
src_y << field_based,
1853
src = s->edge_emu_buffer;
1857
sx = (sx << 2) >> lowres;
1858
sy = (sy << 2) >> lowres;
1622
1860
src += s->linesize;
1623
1861
pix_op[op_index](dest, src, stride, h, sx, sy);
1627
1865
/* apply one mpeg motion vector to the three components */
1628
1866
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1629
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1630
int field_based, int bottom_field, int field_select,
1631
uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1632
int motion_x, int motion_y, int h, int mb_y)
1873
uint8_t **ref_picture,
1874
h264_chroma_mc_func *pix_op,
1875
int motion_x, int motion_y,
1634
1878
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1635
int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1636
const int lowres= s->avctx->lowres;
1637
const int op_index= FFMIN(lowres, 2);
1638
const int block_s= 8>>lowres;
1639
const int s_mask= (2<<lowres)-1;
1879
int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1881
const int lowres = s->avctx->lowres;
1882
const int op_index = FFMIN(lowres, 2);
1883
const int block_s = 8>>lowres;
1884
const int s_mask = (2 << lowres) - 1;
1640
1885
const int h_edge_pos = s->h_edge_pos >> lowres;
1641
1886
const int v_edge_pos = s->v_edge_pos >> lowres;
1642
linesize = s->current_picture.linesize[0] << field_based;
1643
uvlinesize = s->current_picture.linesize[1] << field_based;
1645
if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1651
motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1654
sx= motion_x & s_mask;
1655
sy= motion_y & s_mask;
1656
src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1657
src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1887
linesize = s->current_picture.f.linesize[0] << field_based;
1888
uvlinesize = s->current_picture.f.linesize[1] << field_based;
1890
// FIXME obviously not perfect but qpel will not work in lowres anyway
1891
if (s->quarter_sample) {
1897
motion_y += (bottom_field - field_select) * (1 << lowres - 1);
1900
sx = motion_x & s_mask;
1901
sy = motion_y & s_mask;
1902
src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1903
src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1659
1905
if (s->out_format == FMT_H263) {
1660
uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1661
uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1664
}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1667
uvsx = (2*mx) & s_mask;
1668
uvsy = (2*my) & s_mask;
1669
uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1670
uvsrc_y = mb_y*block_s + (my >> lowres);
1906
uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1907
uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1908
uvsrc_x = src_x >> 1;
1909
uvsrc_y = src_y >> 1;
1910
} else if (s->out_format == FMT_H261) {
1911
// even chroma mv's are full pel in H261
1914
uvsx = (2 * mx) & s_mask;
1915
uvsy = (2 * my) & s_mask;
1916
uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1917
uvsrc_y = mb_y * block_s + (my >> lowres);
1676
uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1677
uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1923
uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1924
uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1680
ptr_y = ref_picture[0] + src_y * linesize + src_x;
1927
ptr_y = ref_picture[0] + src_y * linesize + src_x;
1681
1928
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1682
1929
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1684
if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1685
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1686
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1687
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1688
ptr_y = s->edge_emu_buffer;
1689
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1690
uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1691
s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1692
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1693
s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1694
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1700
if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1701
dest_y += s->linesize;
1702
dest_cb+= s->uvlinesize;
1703
dest_cr+= s->uvlinesize;
1707
ptr_y += s->linesize;
1708
ptr_cb+= s->uvlinesize;
1709
ptr_cr+= s->uvlinesize;
1712
sx= (sx << 2) >> lowres;
1713
sy= (sy << 2) >> lowres;
1714
pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1716
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1717
uvsx= (uvsx << 2) >> lowres;
1718
uvsy= (uvsy << 2) >> lowres;
1719
pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1720
pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1722
//FIXME h261 lowres loop filter
1931
if ((unsigned) src_x > h_edge_pos - (!!sx) - 2 * block_s ||
1932
(unsigned) src_y > (v_edge_pos >> field_based) - (!!sy) - h) {
1933
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
1934
s->linesize, 17, 17 + field_based,
1935
src_x, src_y << field_based, h_edge_pos,
1937
ptr_y = s->edge_emu_buffer;
1938
if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1939
uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
1940
s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
1942
uvsrc_x, uvsrc_y << field_based,
1943
h_edge_pos >> 1, v_edge_pos >> 1);
1944
s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
1946
uvsrc_x, uvsrc_y << field_based,
1947
h_edge_pos >> 1, v_edge_pos >> 1);
1949
ptr_cr = uvbuf + 16;
1953
// FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1955
dest_y += s->linesize;
1956
dest_cb += s->uvlinesize;
1957
dest_cr += s->uvlinesize;
1961
ptr_y += s->linesize;
1962
ptr_cb += s->uvlinesize;
1963
ptr_cr += s->uvlinesize;
1966
sx = (sx << 2) >> lowres;
1967
sy = (sy << 2) >> lowres;
1968
pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1970
if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1971
uvsx = (uvsx << 2) >> lowres;
1972
uvsy = (uvsy << 2) >> lowres;
1973
pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift,
1975
pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift,
1978
// FIXME h261 lowres loop filter
1725
1981
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1726
uint8_t *dest_cb, uint8_t *dest_cr,
1727
uint8_t **ref_picture,
1728
h264_chroma_mc_func *pix_op,
1730
const int lowres= s->avctx->lowres;
1731
const int op_index= FFMIN(lowres, 2);
1732
const int block_s= 8>>lowres;
1733
const int s_mask= (2<<lowres)-1;
1734
const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1735
const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1736
int emu=0, src_x, src_y, offset, sx, sy;
1982
uint8_t *dest_cb, uint8_t *dest_cr,
1983
uint8_t **ref_picture,
1984
h264_chroma_mc_func * pix_op,
1987
const int lowres = s->avctx->lowres;
1988
const int op_index = FFMIN(lowres, 2);
1989
const int block_s = 8 >> lowres;
1990
const int s_mask = (2 << lowres) - 1;
1991
const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1992
const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1993
int emu = 0, src_x, src_y, offset, sx, sy;
1739
if(s->quarter_sample){
1996
if (s->quarter_sample) {
1744
2001
/* In case of 8X8, we construct a single chroma motion vector
1745
2002
with a special rounding */
1746
mx= ff_h263_round_chroma(mx);
1747
my= ff_h263_round_chroma(my);
2003
mx = ff_h263_round_chroma(mx);
2004
my = ff_h263_round_chroma(my);
1751
src_x = s->mb_x*block_s + (mx >> (lowres+1));
1752
src_y = s->mb_y*block_s + (my >> (lowres+1));
2008
src_x = s->mb_x * block_s + (mx >> lowres + 1);
2009
src_y = s->mb_y * block_s + (my >> lowres + 1);
1754
2011
offset = src_y * s->uvlinesize + src_x;
1755
2012
ptr = ref_picture[1] + offset;
1756
if(s->flags&CODEC_FLAG_EMU_EDGE){
1757
if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1758
|| (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1759
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1760
ptr= s->edge_emu_buffer;
2013
if (s->flags & CODEC_FLAG_EMU_EDGE) {
2014
if ((unsigned) src_x > h_edge_pos - (!!sx) - block_s ||
2015
(unsigned) src_y > v_edge_pos - (!!sy) - block_s) {
2016
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2017
9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2018
ptr = s->edge_emu_buffer;
1764
sx= (sx << 2) >> lowres;
1765
sy= (sy << 2) >> lowres;
2022
sx = (sx << 2) >> lowres;
2023
sy = (sy << 2) >> lowres;
1766
2024
pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1768
2026
ptr = ref_picture[2] + offset;
1770
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1771
ptr= s->edge_emu_buffer;
2028
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2029
src_x, src_y, h_edge_pos, v_edge_pos);
2030
ptr = s->edge_emu_buffer;
1773
2032
pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1785
2044
* the motion vectors are taken from s->mv and the MV type from s->mv_type
1787
2046
static inline void MPV_motion_lowres(MpegEncContext *s,
1788
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1789
int dir, uint8_t **ref_picture,
1790
h264_chroma_mc_func *pix_op)
2047
uint8_t *dest_y, uint8_t *dest_cb,
2049
int dir, uint8_t **ref_picture,
2050
h264_chroma_mc_func *pix_op)
1793
2053
int mb_x, mb_y, i;
1794
const int lowres= s->avctx->lowres;
1795
const int block_s= 8>>lowres;
2054
const int lowres = s->avctx->lowres;
2055
const int block_s = 8 >>lowres;
1797
2057
mb_x = s->mb_x;
1798
2058
mb_y = s->mb_y;
1800
switch(s->mv_type) {
2060
switch (s->mv_type) {
1801
2061
case MV_TYPE_16X16:
1802
2062
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1804
ref_picture, pix_op,
1805
s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
2064
ref_picture, pix_op,
2065
s->mv[dir][0][0], s->mv[dir][0][1],
1807
2068
case MV_TYPE_8X8:
1811
hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1812
ref_picture[0], 0, 0,
1813
(2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1814
s->width, s->height, s->linesize,
1815
s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1816
block_s, block_s, pix_op,
1817
s->mv[dir][i][0], s->mv[dir][i][1]);
1819
mx += s->mv[dir][i][0];
1820
my += s->mv[dir][i][1];
1823
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1824
chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
2071
for (i = 0; i < 4; i++) {
2072
hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2073
s->linesize) * block_s,
2074
ref_picture[0], 0, 0,
2075
(2 * mb_x + (i & 1)) * block_s,
2076
(2 * mb_y + (i >> 1)) * block_s,
2077
s->width, s->height, s->linesize,
2078
s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2079
block_s, block_s, pix_op,
2080
s->mv[dir][i][0], s->mv[dir][i][1]);
2082
mx += s->mv[dir][i][0];
2083
my += s->mv[dir][i][1];
2086
if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2087
chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1826
2090
case MV_TYPE_FIELD:
1827
2091
if (s->picture_structure == PICT_FRAME) {
1828
2092
/* top field */
1829
2093
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1830
1, 0, s->field_select[dir][0],
1831
ref_picture, pix_op,
1832
s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
2094
1, 0, s->field_select[dir][0],
2095
ref_picture, pix_op,
2096
s->mv[dir][0][0], s->mv[dir][0][1],
1833
2098
/* bottom field */
1834
2099
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1835
1, 1, s->field_select[dir][1],
1836
ref_picture, pix_op,
1837
s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
2100
1, 1, s->field_select[dir][1],
2101
ref_picture, pix_op,
2102
s->mv[dir][1][0], s->mv[dir][1][1],
1839
if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1840
ref_picture= s->current_picture_ptr->data;
2105
if (s->picture_structure != s->field_select[dir][0] + 1 &&
2106
s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2107
ref_picture = s->current_picture_ptr->f.data;
1843
2110
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1844
0, 0, s->field_select[dir][0],
1845
ref_picture, pix_op,
1846
s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
2111
0, 0, s->field_select[dir][0],
2112
ref_picture, pix_op,
2114
s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1849
2117
case MV_TYPE_16X8:
1851
uint8_t ** ref2picture;
2118
for (i = 0; i < 2; i++) {
2119
uint8_t **ref2picture;
1853
if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1854
ref2picture= ref_picture;
1856
ref2picture= s->current_picture_ptr->data;
2121
if (s->picture_structure == s->field_select[dir][i] + 1 ||
2122
s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2123
ref2picture = ref_picture;
2125
ref2picture = s->current_picture_ptr->f.data;
1859
2128
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1860
0, 0, s->field_select[dir][i],
1861
ref2picture, pix_op,
1862
s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
2129
0, 0, s->field_select[dir][i],
2130
ref2picture, pix_op,
2131
s->mv[dir][i][0], s->mv[dir][i][1] +
2132
2 * block_s * i, block_s, mb_y >> 1);
1864
dest_y += 2*block_s*s->linesize;
1865
dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1866
dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
2134
dest_y += 2 * block_s * s->linesize;
2135
dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2136
dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1869
2139
case MV_TYPE_DMV:
1870
if(s->picture_structure == PICT_FRAME){
2140
if (s->picture_structure == PICT_FRAME) {
2141
for (i = 0; i < 2; i++) {
2143
for (j = 0; j < 2; j++) {
1874
2144
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1876
ref_picture, pix_op,
1877
s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
2146
ref_picture, pix_op,
2147
s->mv[dir][2 * i + j][0],
2148
s->mv[dir][2 * i + j][1],
1879
2151
pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2154
for (i = 0; i < 2; i++) {
1883
2155
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1884
0, 0, s->picture_structure != i+1,
1885
ref_picture, pix_op,
1886
s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
2156
0, 0, s->picture_structure != i + 1,
2157
ref_picture, pix_op,
2158
s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2159
2 * block_s, mb_y >> 1);
1888
2161
// after put we make avg of the same block
1889
2162
pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1891
//opposite parity is always in the same frame if this is second field
1892
if(!s->first_field){
1893
ref_picture = s->current_picture_ptr->data;
2164
// opposite parity is always in the same
2165
// frame if this is second field
2166
if (!s->first_field) {
2167
ref_picture = s->current_picture_ptr->f.data;
added
removed
ffmpeg/libavcodec/mpegvideo.c
