FFmpeg
mpegvideo.c
Go to the documentation of this file.
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
36 
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "h264chroma.h"
40 #include "idctdsp.h"
41 #include "internal.h"
42 #include "mathops.h"
43 #include "mpeg_er.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
46 #include "mpegvideodata.h"
47 #include "mjpegenc.h"
48 #include "msmpeg4.h"
49 #include "qpeldsp.h"
50 #include "thread.h"
51 #include "wmv2.h"
52 #include <limits.h>
53 
55  int16_t *block, int n, int qscale)
56 {
57  int i, level, nCoeffs;
58  const uint16_t *quant_matrix;
59 
60  nCoeffs= s->block_last_index[n];
61 
62  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
63  /* XXX: only MPEG-1 */
64  quant_matrix = s->intra_matrix;
65  for(i=1;i<=nCoeffs;i++) {
66  int j= s->intra_scantable.permutated[i];
67  level = block[j];
68  if (level) {
69  if (level < 0) {
70  level = -level;
71  level = (int)(level * qscale * quant_matrix[j]) >> 3;
72  level = (level - 1) | 1;
73  level = -level;
74  } else {
75  level = (int)(level * qscale * quant_matrix[j]) >> 3;
76  level = (level - 1) | 1;
77  }
78  block[j] = level;
79  }
80  }
81 }
82 
84  int16_t *block, int n, int qscale)
85 {
86  int i, level, nCoeffs;
87  const uint16_t *quant_matrix;
88 
89  nCoeffs= s->block_last_index[n];
90 
91  quant_matrix = s->inter_matrix;
92  for(i=0; i<=nCoeffs; i++) {
93  int j= s->intra_scantable.permutated[i];
94  level = block[j];
95  if (level) {
96  if (level < 0) {
97  level = -level;
98  level = (((level << 1) + 1) * qscale *
99  ((int) (quant_matrix[j]))) >> 4;
100  level = (level - 1) | 1;
101  level = -level;
102  } else {
103  level = (((level << 1) + 1) * qscale *
104  ((int) (quant_matrix[j]))) >> 4;
105  level = (level - 1) | 1;
106  }
107  block[j] = level;
108  }
109  }
110 }
111 
113  int16_t *block, int n, int qscale)
114 {
115  int i, level, nCoeffs;
116  const uint16_t *quant_matrix;
117 
118  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
119  else qscale <<= 1;
120 
121  if(s->alternate_scan) nCoeffs= 63;
122  else nCoeffs= s->block_last_index[n];
123 
124  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
125  quant_matrix = s->intra_matrix;
126  for(i=1;i<=nCoeffs;i++) {
127  int j= s->intra_scantable.permutated[i];
128  level = block[j];
129  if (level) {
130  if (level < 0) {
131  level = -level;
132  level = (int)(level * qscale * quant_matrix[j]) >> 4;
133  level = -level;
134  } else {
135  level = (int)(level * qscale * quant_matrix[j]) >> 4;
136  }
137  block[j] = level;
138  }
139  }
140 }
141 
143  int16_t *block, int n, int qscale)
144 {
145  int i, level, nCoeffs;
146  const uint16_t *quant_matrix;
147  int sum=-1;
148 
149  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
150  else qscale <<= 1;
151 
152  if(s->alternate_scan) nCoeffs= 63;
153  else nCoeffs= s->block_last_index[n];
154 
155  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
156  sum += block[0];
157  quant_matrix = s->intra_matrix;
158  for(i=1;i<=nCoeffs;i++) {
159  int j= s->intra_scantable.permutated[i];
160  level = block[j];
161  if (level) {
162  if (level < 0) {
163  level = -level;
164  level = (int)(level * qscale * quant_matrix[j]) >> 4;
165  level = -level;
166  } else {
167  level = (int)(level * qscale * quant_matrix[j]) >> 4;
168  }
169  block[j] = level;
170  sum+=level;
171  }
172  }
173  block[63]^=sum&1;
174 }
175 
177  int16_t *block, int n, int qscale)
178 {
179  int i, level, nCoeffs;
180  const uint16_t *quant_matrix;
181  int sum=-1;
182 
183  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
184  else qscale <<= 1;
185 
186  if(s->alternate_scan) nCoeffs= 63;
187  else nCoeffs= s->block_last_index[n];
188 
189  quant_matrix = s->inter_matrix;
190  for(i=0; i<=nCoeffs; i++) {
191  int j= s->intra_scantable.permutated[i];
192  level = block[j];
193  if (level) {
194  if (level < 0) {
195  level = -level;
196  level = (((level << 1) + 1) * qscale *
197  ((int) (quant_matrix[j]))) >> 5;
198  level = -level;
199  } else {
200  level = (((level << 1) + 1) * qscale *
201  ((int) (quant_matrix[j]))) >> 5;
202  }
203  block[j] = level;
204  sum+=level;
205  }
206  }
207  block[63]^=sum&1;
208 }
209 
211  int16_t *block, int n, int qscale)
212 {
213  int i, level, qmul, qadd;
214  int nCoeffs;
215 
216  av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
217 
218  qmul = qscale << 1;
219 
220  if (!s->h263_aic) {
221  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
222  qadd = (qscale - 1) | 1;
223  }else{
224  qadd = 0;
225  }
226  if(s->ac_pred)
227  nCoeffs=63;
228  else
229  nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
230 
231  for(i=1; i<=nCoeffs; i++) {
232  level = block[i];
233  if (level) {
234  if (level < 0) {
235  level = level * qmul - qadd;
236  } else {
237  level = level * qmul + qadd;
238  }
239  block[i] = level;
240  }
241  }
242 }
243 
245  int16_t *block, int n, int qscale)
246 {
247  int i, level, qmul, qadd;
248  int nCoeffs;
249 
250  av_assert2(s->block_last_index[n]>=0);
251 
252  qadd = (qscale - 1) | 1;
253  qmul = qscale << 1;
254 
255  nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
256 
257  for(i=0; i<=nCoeffs; i++) {
258  level = block[i];
259  if (level) {
260  if (level < 0) {
261  level = level * qmul - qadd;
262  } else {
263  level = level * qmul + qadd;
264  }
265  block[i] = level;
266  }
267  }
268 }
269 
270 
271 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
272 {
273  while(h--)
274  memset(dst + h*linesize, 128, 16);
275 }
276 
277 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
278 {
279  while(h--)
280  memset(dst + h*linesize, 128, 8);
281 }
282 
283 /* init common dct for both encoder and decoder */
285 {
286  ff_blockdsp_init(&s->bdsp, s->avctx);
287  ff_h264chroma_init(&s->h264chroma, 8); //for lowres
288  ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
289  ff_mpegvideodsp_init(&s->mdsp);
290  ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
291 
292  if (s->avctx->debug & FF_DEBUG_NOMC) {
293  int i;
294  for (i=0; i<4; i++) {
295  s->hdsp.avg_pixels_tab[0][i] = gray16;
296  s->hdsp.put_pixels_tab[0][i] = gray16;
297  s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
298 
299  s->hdsp.avg_pixels_tab[1][i] = gray8;
300  s->hdsp.put_pixels_tab[1][i] = gray8;
301  s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
302  }
303  }
304 
305  s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
306  s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
307  s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
308  s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
309  s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
310  if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
311  s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
312  s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
313 
314  if (HAVE_INTRINSICS_NEON)
316 
317  if (ARCH_ALPHA)
319  if (ARCH_ARM)
321  if (ARCH_PPC)
323  if (ARCH_X86)
325  if (ARCH_MIPS)
327 
328  return 0;
329 }
330 
332 {
333  if (s->codec_id == AV_CODEC_ID_MPEG4)
334  s->idsp.mpeg4_studio_profile = s->studio_profile;
335  ff_idctdsp_init(&s->idsp, s->avctx);
336 
337  /* load & permutate scantables
338  * note: only wmv uses different ones
339  */
340  if (s->alternate_scan) {
341  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
342  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
343  } else {
344  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
345  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
346  }
347  ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
348  ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
349 }
350 
352 {
353  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, 0, 0,
354  s->chroma_x_shift, s->chroma_y_shift, s->out_format,
355  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
356  &s->linesize, &s->uvlinesize);
357 }
358 
360 {
361  int y_size = s->b8_stride * (2 * s->mb_height + 1);
362  int c_size = s->mb_stride * (s->mb_height + 1);
363  int yc_size = y_size + 2 * c_size;
364  int i;
365 
366  if (s->mb_height & 1)
367  yc_size += 2*s->b8_stride + 2*s->mb_stride;
368 
369  if (s->encoding) {
370  if (!FF_ALLOCZ_TYPED_ARRAY(s->me.map, ME_MAP_SIZE) ||
371  !FF_ALLOCZ_TYPED_ARRAY(s->me.score_map, ME_MAP_SIZE))
372  return AVERROR(ENOMEM);
373 
374  if (s->noise_reduction) {
375  if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_error_sum, 2))
376  return AVERROR(ENOMEM);
377  }
378  }
379  if (!FF_ALLOCZ_TYPED_ARRAY(s->blocks, 2))
380  return AVERROR(ENOMEM);
381  s->block = s->blocks[0];
382 
383  for (i = 0; i < 12; i++) {
384  s->pblocks[i] = &s->block[i];
385  }
386 
387  if (!(s->block32 = av_mallocz(sizeof(*s->block32))) ||
388  !(s->dpcm_macroblock = av_mallocz(sizeof(*s->dpcm_macroblock))))
389  return AVERROR(ENOMEM);
390  s->dpcm_direction = 0;
391 
392  if (s->avctx->codec_tag == AV_RL32("VCR2")) {
393  // exchange uv
394  FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
395  }
396 
397  if (s->out_format == FMT_H263) {
398  /* ac values */
399  if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, yc_size))
400  return AVERROR(ENOMEM);
401  s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
402  s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
403  s->ac_val[2] = s->ac_val[1] + c_size;
404  }
405 
406  return 0;
407 }
408 
409 /**
410  * Initialize an MpegEncContext's thread contexts. Presumes that
411  * slice_context_count is already set and that all the fields
412  * that are freed/reset in free_duplicate_context() are NULL.
413  */
415 {
416  int nb_slices = s->slice_context_count, ret;
417 
418  /* We initialize the copies before the original so that
419  * fields allocated in init_duplicate_context are NULL after
420  * copying. This prevents double-frees upon allocation error. */
421  for (int i = 1; i < nb_slices; i++) {
422  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
423  if (!s->thread_context[i])
424  return AVERROR(ENOMEM);
425  if ((ret = init_duplicate_context(s->thread_context[i])) < 0)
426  return ret;
427  s->thread_context[i]->start_mb_y =
428  (s->mb_height * (i ) + nb_slices / 2) / nb_slices;
429  s->thread_context[i]->end_mb_y =
430  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
431  }
432  s->start_mb_y = 0;
433  s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices
434  : s->mb_height;
435  return init_duplicate_context(s);
436 }
437 
439 {
440  if (!s)
441  return;
442 
443  av_freep(&s->sc.edge_emu_buffer);
444  av_freep(&s->me.scratchpad);
445  s->me.temp =
446  s->sc.rd_scratchpad =
447  s->sc.b_scratchpad =
448  s->sc.obmc_scratchpad = NULL;
449 
450  av_freep(&s->dct_error_sum);
451  av_freep(&s->me.map);
452  av_freep(&s->me.score_map);
453  av_freep(&s->blocks);
454  av_freep(&s->block32);
455  av_freep(&s->dpcm_macroblock);
456  av_freep(&s->ac_val_base);
457  s->block = NULL;
458 }
459 
461 {
462  for (int i = 1; i < s->slice_context_count; i++) {
463  free_duplicate_context(s->thread_context[i]);
464  av_freep(&s->thread_context[i]);
465  }
467 }
468 
470 {
471 #define COPY(a) bak->a = src->a
472  COPY(sc.edge_emu_buffer);
473  COPY(me.scratchpad);
474  COPY(me.temp);
475  COPY(sc.rd_scratchpad);
476  COPY(sc.b_scratchpad);
477  COPY(sc.obmc_scratchpad);
478  COPY(me.map);
479  COPY(me.score_map);
480  COPY(blocks);
481  COPY(block);
482  COPY(block32);
483  COPY(dpcm_macroblock);
484  COPY(dpcm_direction);
485  COPY(start_mb_y);
486  COPY(end_mb_y);
487  COPY(me.map_generation);
488  COPY(pb);
489  COPY(dct_error_sum);
490  COPY(dct_count[0]);
491  COPY(dct_count[1]);
492  COPY(ac_val_base);
493  COPY(ac_val[0]);
494  COPY(ac_val[1]);
495  COPY(ac_val[2]);
496 #undef COPY
497 }
498 
500 {
501  MpegEncContext bak;
502  int i, ret;
503  // FIXME copy only needed parts
504  backup_duplicate_context(&bak, dst);
505  memcpy(dst, src, sizeof(MpegEncContext));
506  backup_duplicate_context(dst, &bak);
507  for (i = 0; i < 12; i++) {
508  dst->pblocks[i] = &dst->block[i];
509  }
510  if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
511  // exchange uv
512  FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
513  }
514  if (!dst->sc.edge_emu_buffer &&
515  (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
516  &dst->sc, dst->linesize)) < 0) {
517  av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
518  "scratch buffers.\n");
519  return ret;
520  }
521  return 0;
522 }
523 
525  const AVCodecContext *src)
526 {
527  int i, ret;
528  MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
529 
530  if (dst == src)
531  return 0;
532 
533  av_assert0(s != s1);
534 
535  // FIXME can parameters change on I-frames?
536  // in that case dst may need a reinit
537  if (!s->context_initialized) {
538  int err;
539  memcpy(s, s1, sizeof(MpegEncContext));
540 
541  s->avctx = dst;
542  s->bitstream_buffer = NULL;
543  s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
544 
545  if (s1->context_initialized){
546 // s->picture_range_start += MAX_PICTURE_COUNT;
547 // s->picture_range_end += MAX_PICTURE_COUNT;
549  if((err = ff_mpv_common_init(s)) < 0){
550  memset(s, 0, sizeof(MpegEncContext));
551  s->avctx = dst;
552  return err;
553  }
554  }
555  }
556 
557  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
558  s->height = s1->height;
559  s->width = s1->width;
561  return ret;
562  }
563 
564  s->avctx->coded_height = s1->avctx->coded_height;
565  s->avctx->coded_width = s1->avctx->coded_width;
566  s->avctx->width = s1->avctx->width;
567  s->avctx->height = s1->avctx->height;
568 
569  s->quarter_sample = s1->quarter_sample;
570 
571  s->coded_picture_number = s1->coded_picture_number;
572  s->picture_number = s1->picture_number;
573 
574  av_assert0(!s->picture || s->picture != s1->picture);
575  if(s->picture)
576  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
577  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
578  if (s1->picture && s1->picture[i].f->buf[0] &&
579  (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
580  return ret;
581  }
582 
583 #define UPDATE_PICTURE(pic)\
584 do {\
585  ff_mpeg_unref_picture(s->avctx, &s->pic);\
586  if (s1->pic.f && s1->pic.f->buf[0])\
587  ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
588  else\
589  ret = ff_update_picture_tables(&s->pic, &s1->pic);\
590  if (ret < 0)\
591  return ret;\
592 } while (0)
593 
594  UPDATE_PICTURE(current_picture);
596  UPDATE_PICTURE(next_picture);
597 
598 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
599  ((pic && pic >= old_ctx->picture && \
600  pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
601  &new_ctx->picture[pic - old_ctx->picture] : NULL)
602 
603  s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
604  s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
605  s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
606 
607  // Error/bug resilience
608  s->next_p_frame_damaged = s1->next_p_frame_damaged;
609  s->workaround_bugs = s1->workaround_bugs;
610  s->padding_bug_score = s1->padding_bug_score;
611 
612  // MPEG-4 timing info
613  memcpy(&s->last_time_base, &s1->last_time_base,
614  (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
615  (char *) &s1->last_time_base);
616 
617  // B-frame info
618  s->max_b_frames = s1->max_b_frames;
619  s->low_delay = s1->low_delay;
620  s->droppable = s1->droppable;
621 
622  // DivX handling (doesn't work)
623  s->divx_packed = s1->divx_packed;
624 
625  if (s1->bitstream_buffer) {
626  if (s1->bitstream_buffer_size +
627  AV_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
628  av_fast_malloc(&s->bitstream_buffer,
629  &s->allocated_bitstream_buffer_size,
630  s1->allocated_bitstream_buffer_size);
631  if (!s->bitstream_buffer) {
632  s->bitstream_buffer_size = 0;
633  return AVERROR(ENOMEM);
634  }
635  }
636  s->bitstream_buffer_size = s1->bitstream_buffer_size;
637  memcpy(s->bitstream_buffer, s1->bitstream_buffer,
638  s1->bitstream_buffer_size);
639  memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
641  }
642 
643  // linesize-dependent scratch buffer allocation
644  if (!s->sc.edge_emu_buffer)
645  if (s1->linesize) {
646  if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
647  &s->sc, s1->linesize) < 0) {
648  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
649  "scratch buffers.\n");
650  return AVERROR(ENOMEM);
651  }
652  } else {
653  av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
654  "be allocated due to unknown size.\n");
655  }
656 
657  // MPEG-2/interlacing info
658  memcpy(&s->progressive_sequence, &s1->progressive_sequence,
659  (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
660 
661  if (!s1->first_field) {
662  s->last_pict_type = s1->pict_type;
663  if (s1->current_picture_ptr)
664  s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
665  }
666 
667  return 0;
668 }
669 
670 /**
671  * Set the given MpegEncContext to common defaults
672  * (same for encoding and decoding).
673  * The changed fields will not depend upon the
674  * prior state of the MpegEncContext.
675  */
677 {
678  s->y_dc_scale_table =
679  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
680  s->chroma_qscale_table = ff_default_chroma_qscale_table;
681  s->progressive_frame = 1;
682  s->progressive_sequence = 1;
683  s->picture_structure = PICT_FRAME;
684 
685  s->coded_picture_number = 0;
686  s->picture_number = 0;
687 
688  s->f_code = 1;
689  s->b_code = 1;
690 
691  s->slice_context_count = 1;
692 }
693 
694 /**
695  * Initialize the given MpegEncContext for decoding.
696  * the changed fields will not depend upon
697  * the prior state of the MpegEncContext.
698  */
700 {
702 
703  s->avctx = avctx;
704  s->width = avctx->coded_width;
705  s->height = avctx->coded_height;
706  s->codec_id = avctx->codec->id;
707  s->workaround_bugs = avctx->workaround_bugs;
708 
709  /* convert fourcc to upper case */
710  s->codec_tag = avpriv_toupper4(avctx->codec_tag);
711 }
712 
713 /**
714  * Initialize and allocates MpegEncContext fields dependent on the resolution.
715  */
717 {
718  int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
719 
720  s->mb_width = (s->width + 15) / 16;
721  s->mb_stride = s->mb_width + 1;
722  s->b8_stride = s->mb_width * 2 + 1;
723  mb_array_size = s->mb_height * s->mb_stride;
724  mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
725 
726  /* set default edge pos, will be overridden
727  * in decode_header if needed */
728  s->h_edge_pos = s->mb_width * 16;
729  s->v_edge_pos = s->mb_height * 16;
730 
731  s->mb_num = s->mb_width * s->mb_height;
732 
733  s->block_wrap[0] =
734  s->block_wrap[1] =
735  s->block_wrap[2] =
736  s->block_wrap[3] = s->b8_stride;
737  s->block_wrap[4] =
738  s->block_wrap[5] = s->mb_stride;
739 
740  y_size = s->b8_stride * (2 * s->mb_height + 1);
741  c_size = s->mb_stride * (s->mb_height + 1);
742  yc_size = y_size + 2 * c_size;
743 
744  if (s->mb_height & 1)
745  yc_size += 2*s->b8_stride + 2*s->mb_stride;
746 
747  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1))
748  return AVERROR(ENOMEM);
749  for (y = 0; y < s->mb_height; y++)
750  for (x = 0; x < s->mb_width; x++)
751  s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
752 
753  s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
754 
755  if (s->encoding) {
756  /* Allocate MV tables */
757  if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base, mv_table_size) ||
758  !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base, mv_table_size) ||
759  !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base, mv_table_size) ||
760  !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
761  !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
762  !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base, mv_table_size))
763  return AVERROR(ENOMEM);
764  s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
765  s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
766  s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
767  s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
768  s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
769  s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
770 
771  /* Allocate MB type table */
772  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type, mb_array_size) ||
773  !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
774  !FF_ALLOC_TYPED_ARRAY (s->cplx_tab, mb_array_size) ||
775  !FF_ALLOC_TYPED_ARRAY (s->bits_tab, mb_array_size))
776  return AVERROR(ENOMEM);
777  }
778 
779  if (s->codec_id == AV_CODEC_ID_MPEG4 ||
780  (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
781  /* interlaced direct mode decoding tables */
782  for (i = 0; i < 2; i++) {
783  int j, k;
784  for (j = 0; j < 2; j++) {
785  for (k = 0; k < 2; k++) {
786  if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_mv_table_base[i][j][k], mv_table_size))
787  return AVERROR(ENOMEM);
788  s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
789  s->mb_stride + 1;
790  }
791  if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_select_table [i][j], mv_table_size * 2) ||
792  !FF_ALLOCZ_TYPED_ARRAY(s->p_field_mv_table_base[i][j], mv_table_size))
793  return AVERROR(ENOMEM);
794  s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
795  }
796  if (!FF_ALLOCZ_TYPED_ARRAY(s->p_field_select_table[i], mv_table_size * 2))
797  return AVERROR(ENOMEM);
798  }
799  }
800  if (s->out_format == FMT_H263) {
801  /* cbp values, cbp, ac_pred, pred_dir */
802  if (!FF_ALLOCZ_TYPED_ARRAY(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride) ||
803  !FF_ALLOCZ_TYPED_ARRAY(s->cbp_table, mb_array_size) ||
804  !FF_ALLOCZ_TYPED_ARRAY(s->pred_dir_table, mb_array_size))
805  return AVERROR(ENOMEM);
806  s->coded_block = s->coded_block_base + s->b8_stride + 1;
807  }
808 
809  if (s->h263_pred || s->h263_plus || !s->encoding) {
810  /* dc values */
811  // MN: we need these for error resilience of intra-frames
812  if (!FF_ALLOCZ_TYPED_ARRAY(s->dc_val_base, yc_size))
813  return AVERROR(ENOMEM);
814  s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
815  s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
816  s->dc_val[2] = s->dc_val[1] + c_size;
817  for (i = 0; i < yc_size; i++)
818  s->dc_val_base[i] = 1024;
819  }
820 
821  /* which mb is an intra block, init macroblock skip table */
822  if (!FF_ALLOC_TYPED_ARRAY(s->mbintra_table, mb_array_size) ||
823  // Note the + 1 is for a quicker MPEG-4 slice_end detection
824  !FF_ALLOCZ_TYPED_ARRAY(s->mbskip_table, mb_array_size + 2))
825  return AVERROR(ENOMEM);
826  memset(s->mbintra_table, 1, mb_array_size);
827 
828  return ff_mpeg_er_init(s);
829 }
830 
832 {
833  int i, j, k;
834 
835  memset(&s->next_picture, 0, sizeof(s->next_picture));
836  memset(&s->last_picture, 0, sizeof(s->last_picture));
837  memset(&s->current_picture, 0, sizeof(s->current_picture));
838  memset(&s->new_picture, 0, sizeof(s->new_picture));
839 
840  memset(s->thread_context, 0, sizeof(s->thread_context));
841 
842  s->me.map = NULL;
843  s->me.score_map = NULL;
844  s->dct_error_sum = NULL;
845  s->block = NULL;
846  s->blocks = NULL;
847  s->block32 = NULL;
848  memset(s->pblocks, 0, sizeof(s->pblocks));
849  s->dpcm_direction = 0;
850  s->dpcm_macroblock = NULL;
851  s->ac_val_base = NULL;
852  s->ac_val[0] =
853  s->ac_val[1] =
854  s->ac_val[2] =NULL;
855  s->sc.edge_emu_buffer = NULL;
856  s->me.scratchpad = NULL;
857  s->me.temp =
858  s->sc.rd_scratchpad =
859  s->sc.b_scratchpad =
860  s->sc.obmc_scratchpad = NULL;
861 
862 
863  s->bitstream_buffer = NULL;
864  s->allocated_bitstream_buffer_size = 0;
865  s->picture = NULL;
866  s->mb_type = NULL;
867  s->p_mv_table_base = NULL;
868  s->b_forw_mv_table_base = NULL;
869  s->b_back_mv_table_base = NULL;
870  s->b_bidir_forw_mv_table_base = NULL;
871  s->b_bidir_back_mv_table_base = NULL;
872  s->b_direct_mv_table_base = NULL;
873  s->p_mv_table = NULL;
874  s->b_forw_mv_table = NULL;
875  s->b_back_mv_table = NULL;
876  s->b_bidir_forw_mv_table = NULL;
877  s->b_bidir_back_mv_table = NULL;
878  s->b_direct_mv_table = NULL;
879  for (i = 0; i < 2; i++) {
880  for (j = 0; j < 2; j++) {
881  for (k = 0; k < 2; k++) {
882  s->b_field_mv_table_base[i][j][k] = NULL;
883  s->b_field_mv_table[i][j][k] = NULL;
884  }
885  s->b_field_select_table[i][j] = NULL;
886  s->p_field_mv_table_base[i][j] = NULL;
887  s->p_field_mv_table[i][j] = NULL;
888  }
889  s->p_field_select_table[i] = NULL;
890  }
891 
892  s->dc_val_base = NULL;
893  s->coded_block_base = NULL;
894  s->mbintra_table = NULL;
895  s->cbp_table = NULL;
896  s->pred_dir_table = NULL;
897 
898  s->mbskip_table = NULL;
899 
900  s->er.error_status_table = NULL;
901  s->er.er_temp_buffer = NULL;
902  s->mb_index2xy = NULL;
903  s->lambda_table = NULL;
904 
905  s->cplx_tab = NULL;
906  s->bits_tab = NULL;
907 }
908 
909 /**
910  * init common structure for both encoder and decoder.
911  * this assumes that some variables like width/height are already set
912  */
914 {
915  int i, ret;
916  int nb_slices = (HAVE_THREADS &&
917  s->avctx->active_thread_type & FF_THREAD_SLICE) ?
918  s->avctx->thread_count : 1;
919 
920  clear_context(s);
921 
922  if (s->encoding && s->avctx->slices)
923  nb_slices = s->avctx->slices;
924 
925  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
926  s->mb_height = (s->height + 31) / 32 * 2;
927  else
928  s->mb_height = (s->height + 15) / 16;
929 
930  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
931  av_log(s->avctx, AV_LOG_ERROR,
932  "decoding to AV_PIX_FMT_NONE is not supported.\n");
933  return AVERROR(EINVAL);
934  }
935 
936  if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
937  int max_slices;
938  if (s->mb_height)
939  max_slices = FFMIN(MAX_THREADS, s->mb_height);
940  else
941  max_slices = MAX_THREADS;
942  av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
943  " reducing to %d\n", nb_slices, max_slices);
944  nb_slices = max_slices;
945  }
946 
947  if ((s->width || s->height) &&
948  av_image_check_size(s->width, s->height, 0, s->avctx))
949  return AVERROR(EINVAL);
950 
951  dct_init(s);
952 
953  /* set chroma shifts */
954  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
955  &s->chroma_x_shift,
956  &s->chroma_y_shift);
957  if (ret)
958  return ret;
959 
960  if (!FF_ALLOCZ_TYPED_ARRAY(s->picture, MAX_PICTURE_COUNT))
961  return AVERROR(ENOMEM);
962  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
963  s->picture[i].f = av_frame_alloc();
964  if (!s->picture[i].f)
965  goto fail_nomem;
966  }
967 
968  if (!(s->next_picture.f = av_frame_alloc()) ||
969  !(s->last_picture.f = av_frame_alloc()) ||
970  !(s->current_picture.f = av_frame_alloc()) ||
971  !(s->new_picture.f = av_frame_alloc()))
972  goto fail_nomem;
973 
974  if ((ret = init_context_frame(s)))
975  goto fail;
976 
977  s->parse_context.state = -1;
978 
979  s->context_initialized = 1;
980  memset(s->thread_context, 0, sizeof(s->thread_context));
981  s->thread_context[0] = s;
982  s->slice_context_count = nb_slices;
983 
984 // if (s->width && s->height) {
986  if (ret < 0)
987  goto fail;
988 // }
989 
990  return 0;
991  fail_nomem:
992  ret = AVERROR(ENOMEM);
993  fail:
995  return ret;
996 }
997 
998 /**
999  * Frees and resets MpegEncContext fields depending on the resolution
1000  * as well as the slice thread contexts.
1001  * Is used during resolution changes to avoid a full reinitialization of the
1002  * codec.
1003  */
1005 {
1006  int i, j, k;
1007 
1009 
1010  av_freep(&s->mb_type);
1011  av_freep(&s->p_mv_table_base);
1012  av_freep(&s->b_forw_mv_table_base);
1013  av_freep(&s->b_back_mv_table_base);
1014  av_freep(&s->b_bidir_forw_mv_table_base);
1015  av_freep(&s->b_bidir_back_mv_table_base);
1016  av_freep(&s->b_direct_mv_table_base);
1017  s->p_mv_table = NULL;
1018  s->b_forw_mv_table = NULL;
1019  s->b_back_mv_table = NULL;
1020  s->b_bidir_forw_mv_table = NULL;
1021  s->b_bidir_back_mv_table = NULL;
1022  s->b_direct_mv_table = NULL;
1023  for (i = 0; i < 2; i++) {
1024  for (j = 0; j < 2; j++) {
1025  for (k = 0; k < 2; k++) {
1026  av_freep(&s->b_field_mv_table_base[i][j][k]);
1027  s->b_field_mv_table[i][j][k] = NULL;
1028  }
1029  av_freep(&s->b_field_select_table[i][j]);
1030  av_freep(&s->p_field_mv_table_base[i][j]);
1031  s->p_field_mv_table[i][j] = NULL;
1032  }
1033  av_freep(&s->p_field_select_table[i]);
1034  }
1035 
1036  av_freep(&s->dc_val_base);
1037  av_freep(&s->coded_block_base);
1038  av_freep(&s->mbintra_table);
1039  av_freep(&s->cbp_table);
1040  av_freep(&s->pred_dir_table);
1041 
1042  av_freep(&s->mbskip_table);
1043 
1044  av_freep(&s->er.error_status_table);
1045  av_freep(&s->er.er_temp_buffer);
1046  av_freep(&s->mb_index2xy);
1047  av_freep(&s->lambda_table);
1048 
1049  av_freep(&s->cplx_tab);
1050  av_freep(&s->bits_tab);
1051 
1052  s->linesize = s->uvlinesize = 0;
1053 }
1054 
1056 {
1057  int i, err = 0;
1058 
1059  if (!s->context_initialized)
1060  return AVERROR(EINVAL);
1061 
1063 
1064  if (s->picture)
1065  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1066  s->picture[i].needs_realloc = 1;
1067  }
1068 
1069  s->last_picture_ptr =
1070  s->next_picture_ptr =
1071  s->current_picture_ptr = NULL;
1072 
1073  // init
1074  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1075  s->mb_height = (s->height + 31) / 32 * 2;
1076  else
1077  s->mb_height = (s->height + 15) / 16;
1078 
1079  if ((s->width || s->height) &&
1080  (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1081  goto fail;
1082 
1083  /* set chroma shifts */
1084  err = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1085  &s->chroma_x_shift,
1086  &s->chroma_y_shift);
1087  if (err < 0)
1088  goto fail;
1089 
1090  if ((err = init_context_frame(s)))
1091  goto fail;
1092 
1093  memset(s->thread_context, 0, sizeof(s->thread_context));
1094  s->thread_context[0] = s;
1095 
1096  if (s->width && s->height) {
1097  err = init_duplicate_contexts(s);
1098  if (err < 0)
1099  goto fail;
1100  }
1101  s->context_reinit = 0;
1102 
1103  return 0;
1104  fail:
1106  s->context_reinit = 1;
1107  return err;
1108 }
1109 
1110 /* init common structure for both encoder and decoder */
1112 {
1113  int i;
1114 
1115  if (!s)
1116  return;
1117 
1119  if (s->slice_context_count > 1)
1120  s->slice_context_count = 1;
1121 
1122  av_freep(&s->parse_context.buffer);
1123  s->parse_context.buffer_size = 0;
1124 
1125  av_freep(&s->bitstream_buffer);
1126  s->allocated_bitstream_buffer_size = 0;
1127 
1128  if (!s->avctx)
1129  return;
1130 
1131  if (s->picture) {
1132  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1133  ff_free_picture_tables(&s->picture[i]);
1134  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1135  av_frame_free(&s->picture[i].f);
1136  }
1137  }
1138  av_freep(&s->picture);
1139  ff_free_picture_tables(&s->last_picture);
1140  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1141  av_frame_free(&s->last_picture.f);
1142  ff_free_picture_tables(&s->current_picture);
1143  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1144  av_frame_free(&s->current_picture.f);
1145  ff_free_picture_tables(&s->next_picture);
1146  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1147  av_frame_free(&s->next_picture.f);
1148  ff_free_picture_tables(&s->new_picture);
1149  ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1150  av_frame_free(&s->new_picture.f);
1151 
1152  s->context_initialized = 0;
1153  s->context_reinit = 0;
1154  s->last_picture_ptr =
1155  s->next_picture_ptr =
1156  s->current_picture_ptr = NULL;
1157  s->linesize = s->uvlinesize = 0;
1158 }
1159 
1160 
1161 static void gray_frame(AVFrame *frame)
1162 {
1163  int i, h_chroma_shift, v_chroma_shift;
1164 
1165  av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1166 
1167  for(i=0; i<frame->height; i++)
1168  memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1169  for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1170  memset(frame->data[1] + frame->linesize[1]*i,
1171  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1172  memset(frame->data[2] + frame->linesize[2]*i,
1173  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1174  }
1175 }
1176 
1177 /**
1178  * generic function called after decoding
1179  * the header and before a frame is decoded.
1180  */
1182 {
1183  int i, ret;
1184  Picture *pic;
1185  s->mb_skipped = 0;
1186 
1187  if (!ff_thread_can_start_frame(avctx)) {
1188  av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1189  return -1;
1190  }
1191 
1192  /* mark & release old frames */
1193  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1194  s->last_picture_ptr != s->next_picture_ptr &&
1195  s->last_picture_ptr->f->buf[0]) {
1196  ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1197  }
1198 
1199  /* release forgotten pictures */
1200  /* if (MPEG-124 / H.263) */
1201  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1202  if (&s->picture[i] != s->last_picture_ptr &&
1203  &s->picture[i] != s->next_picture_ptr &&
1204  s->picture[i].reference && !s->picture[i].needs_realloc) {
1205  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1206  }
1207  }
1208 
1209  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1210  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1211  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1212 
1213  /* release non reference frames */
1214  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1215  if (!s->picture[i].reference)
1216  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1217  }
1218 
1219  if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1220  // we already have an unused image
1221  // (maybe it was set before reading the header)
1222  pic = s->current_picture_ptr;
1223  } else {
1224  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1225  if (i < 0) {
1226  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1227  return i;
1228  }
1229  pic = &s->picture[i];
1230  }
1231 
1232  pic->reference = 0;
1233  if (!s->droppable) {
1234  if (s->pict_type != AV_PICTURE_TYPE_B)
1235  pic->reference = 3;
1236  }
1237 
1238  pic->f->coded_picture_number = s->coded_picture_number++;
1239 
1240  if (alloc_picture(s, pic) < 0)
1241  return -1;
1242 
1243  s->current_picture_ptr = pic;
1244  // FIXME use only the vars from current_pic
1245  s->current_picture_ptr->f->top_field_first = s->top_field_first;
1246  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1247  s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1248  if (s->picture_structure != PICT_FRAME)
1249  s->current_picture_ptr->f->top_field_first =
1250  (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1251  }
1252  s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1253  !s->progressive_sequence;
1254  s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1255 
1256  s->current_picture_ptr->f->pict_type = s->pict_type;
1257  // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1258  // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1259  s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1260 
1261  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1262  s->current_picture_ptr)) < 0)
1263  return ret;
1264 
1265  if (s->pict_type != AV_PICTURE_TYPE_B) {
1266  s->last_picture_ptr = s->next_picture_ptr;
1267  if (!s->droppable)
1268  s->next_picture_ptr = s->current_picture_ptr;
1269  }
1270  ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1271  s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1272  s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1273  s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1274  s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1275  s->pict_type, s->droppable);
1276 
1277  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1278  (s->pict_type != AV_PICTURE_TYPE_I)) {
1279  int h_chroma_shift, v_chroma_shift;
1280  av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1281  &h_chroma_shift, &v_chroma_shift);
1282  if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1283  av_log(avctx, AV_LOG_DEBUG,
1284  "allocating dummy last picture for B frame\n");
1285  else if (s->pict_type != AV_PICTURE_TYPE_I)
1286  av_log(avctx, AV_LOG_ERROR,
1287  "warning: first frame is no keyframe\n");
1288 
1289  /* Allocate a dummy frame */
1290  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1291  if (i < 0) {
1292  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1293  return i;
1294  }
1295  s->last_picture_ptr = &s->picture[i];
1296 
1297  s->last_picture_ptr->reference = 3;
1298  s->last_picture_ptr->f->key_frame = 0;
1299  s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1300 
1301  if (alloc_picture(s, s->last_picture_ptr) < 0) {
1302  s->last_picture_ptr = NULL;
1303  return -1;
1304  }
1305 
1306  if (!avctx->hwaccel) {
1307  for(i=0; i<avctx->height; i++)
1308  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1309  0x80, avctx->width);
1310  if (s->last_picture_ptr->f->data[2]) {
1311  for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1312  memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1313  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1314  memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1315  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1316  }
1317  }
1318 
1319  if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1320  for(i=0; i<avctx->height; i++)
1321  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1322  }
1323  }
1324 
1325  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1326  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1327  }
1328  if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1329  s->pict_type == AV_PICTURE_TYPE_B) {
1330  /* Allocate a dummy frame */
1331  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1332  if (i < 0) {
1333  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1334  return i;
1335  }
1336  s->next_picture_ptr = &s->picture[i];
1337 
1338  s->next_picture_ptr->reference = 3;
1339  s->next_picture_ptr->f->key_frame = 0;
1340  s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1341 
1342  if (alloc_picture(s, s->next_picture_ptr) < 0) {
1343  s->next_picture_ptr = NULL;
1344  return -1;
1345  }
1346  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1347  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1348  }
1349 
1350 #if 0 // BUFREF-FIXME
1351  memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1352  memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1353 #endif
1354  if (s->last_picture_ptr) {
1355  if (s->last_picture_ptr->f->buf[0] &&
1356  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1357  s->last_picture_ptr)) < 0)
1358  return ret;
1359  }
1360  if (s->next_picture_ptr) {
1361  if (s->next_picture_ptr->f->buf[0] &&
1362  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1363  s->next_picture_ptr)) < 0)
1364  return ret;
1365  }
1366 
1367  av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1368  s->last_picture_ptr->f->buf[0]));
1369 
1370  if (s->picture_structure!= PICT_FRAME) {
1371  int i;
1372  for (i = 0; i < 4; i++) {
1373  if (s->picture_structure == PICT_BOTTOM_FIELD) {
1374  s->current_picture.f->data[i] +=
1375  s->current_picture.f->linesize[i];
1376  }
1377  s->current_picture.f->linesize[i] *= 2;
1378  s->last_picture.f->linesize[i] *= 2;
1379  s->next_picture.f->linesize[i] *= 2;
1380  }
1381  }
1382 
1383  /* set dequantizer, we can't do it during init as
1384  * it might change for MPEG-4 and we can't do it in the header
1385  * decode as init is not called for MPEG-4 there yet */
1386  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1387  s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1388  s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1389  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1390  s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1391  s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1392  } else {
1393  s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1394  s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1395  }
1396 
1397  if (s->avctx->debug & FF_DEBUG_NOMC) {
1398  gray_frame(s->current_picture_ptr->f);
1399  }
1400 
1401  return 0;
1402 }
1403 
1404 /* called after a frame has been decoded. */
1406 {
1407  emms_c();
1408 
1409  if (s->current_picture.reference)
1410  ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1411 }
1412 
1414 {
1415  ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
1416  p->qscale_table, p->motion_val, &s->low_delay,
1417  s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1418 }
1419 
1421 {
1422  AVVideoEncParams *par;
1423  int mult = (qp_type == FF_QSCALE_TYPE_MPEG1) ? 2 : 1;
1424  unsigned int nb_mb = p->alloc_mb_height * p->alloc_mb_width;
1425  unsigned int x, y;
1426 
1427  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS))
1428  return 0;
1429 
1431  if (!par)
1432  return AVERROR(ENOMEM);
1433 
1434  for (y = 0; y < p->alloc_mb_height; y++)
1435  for (x = 0; x < p->alloc_mb_width; x++) {
1436  const unsigned int block_idx = y * p->alloc_mb_width + x;
1437  const unsigned int mb_xy = y * p->alloc_mb_stride + x;
1438  AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx);
1439 
1440  b->src_x = x * 16;
1441  b->src_y = y * 16;
1442  b->w = 16;
1443  b->h = 16;
1444 
1445  b->delta_qp = p->qscale_table[mb_xy] * mult;
1446  }
1447 
1448  return 0;
1449 }
1450 
1452  uint8_t *dest, uint8_t *src,
1453  int field_based, int field_select,
1454  int src_x, int src_y,
1455  int width, int height, ptrdiff_t stride,
1456  int h_edge_pos, int v_edge_pos,
1457  int w, int h, h264_chroma_mc_func *pix_op,
1458  int motion_x, int motion_y)
1459 {
1460  const int lowres = s->avctx->lowres;
1461  const int op_index = FFMIN(lowres, 3);
1462  const int s_mask = (2 << lowres) - 1;
1463  int emu = 0;
1464  int sx, sy;
1465 
1466  if (s->quarter_sample) {
1467  motion_x /= 2;
1468  motion_y /= 2;
1469  }
1470 
1471  sx = motion_x & s_mask;
1472  sy = motion_y & s_mask;
1473  src_x += motion_x >> lowres + 1;
1474  src_y += motion_y >> lowres + 1;
1475 
1476  src += src_y * stride + src_x;
1477 
1478  if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1479  (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1480  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
1481  s->linesize, s->linesize,
1482  w + 1, (h + 1) << field_based,
1483  src_x, src_y << field_based,
1484  h_edge_pos, v_edge_pos);
1485  src = s->sc.edge_emu_buffer;
1486  emu = 1;
1487  }
1488 
1489  sx = (sx << 2) >> lowres;
1490  sy = (sy << 2) >> lowres;
1491  if (field_select)
1492  src += s->linesize;
1493  pix_op[op_index](dest, src, stride, h, sx, sy);
1494  return emu;
1495 }
1496 
1497 /* apply one mpeg motion vector to the three components */
1499  uint8_t *dest_y,
1500  uint8_t *dest_cb,
1501  uint8_t *dest_cr,
1502  int field_based,
1503  int bottom_field,
1504  int field_select,
1505  uint8_t **ref_picture,
1506  h264_chroma_mc_func *pix_op,
1507  int motion_x, int motion_y,
1508  int h, int mb_y)
1509 {
1510  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1511  int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
1512  ptrdiff_t uvlinesize, linesize;
1513  const int lowres = s->avctx->lowres;
1514  const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
1515  const int block_s = 8>>lowres;
1516  const int s_mask = (2 << lowres) - 1;
1517  const int h_edge_pos = s->h_edge_pos >> lowres;
1518  const int v_edge_pos = s->v_edge_pos >> lowres;
1519  linesize = s->current_picture.f->linesize[0] << field_based;
1520  uvlinesize = s->current_picture.f->linesize[1] << field_based;
1521 
1522  // FIXME obviously not perfect but qpel will not work in lowres anyway
1523  if (s->quarter_sample) {
1524  motion_x /= 2;
1525  motion_y /= 2;
1526  }
1527 
1528  if(field_based){
1529  motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1530  }
1531 
1532  sx = motion_x & s_mask;
1533  sy = motion_y & s_mask;
1534  src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1535  src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1536 
1537  if (s->out_format == FMT_H263) {
1538  uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1539  uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1540  uvsrc_x = src_x >> 1;
1541  uvsrc_y = src_y >> 1;
1542  } else if (s->out_format == FMT_H261) {
1543  // even chroma mv's are full pel in H261
1544  mx = motion_x / 4;
1545  my = motion_y / 4;
1546  uvsx = (2 * mx) & s_mask;
1547  uvsy = (2 * my) & s_mask;
1548  uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1549  uvsrc_y = mb_y * block_s + (my >> lowres);
1550  } else {
1551  if(s->chroma_y_shift){
1552  mx = motion_x / 2;
1553  my = motion_y / 2;
1554  uvsx = mx & s_mask;
1555  uvsy = my & s_mask;
1556  uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1557  uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1558  } else {
1559  if(s->chroma_x_shift){
1560  //Chroma422
1561  mx = motion_x / 2;
1562  uvsx = mx & s_mask;
1563  uvsy = motion_y & s_mask;
1564  uvsrc_y = src_y;
1565  uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1566  } else {
1567  //Chroma444
1568  uvsx = motion_x & s_mask;
1569  uvsy = motion_y & s_mask;
1570  uvsrc_x = src_x;
1571  uvsrc_y = src_y;
1572  }
1573  }
1574  }
1575 
1576  ptr_y = ref_picture[0] + src_y * linesize + src_x;
1577  ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1578  ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1579 
1580  if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
1581  (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1582  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
1583  linesize >> field_based, linesize >> field_based,
1584  17, 17 + field_based,
1585  src_x, src_y << field_based, h_edge_pos,
1586  v_edge_pos);
1587  ptr_y = s->sc.edge_emu_buffer;
1588  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1589  uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
1590  uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
1591  if (s->workaround_bugs & FF_BUG_IEDGE)
1592  vbuf -= s->uvlinesize;
1593  s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
1594  uvlinesize >> field_based, uvlinesize >> field_based,
1595  9, 9 + field_based,
1596  uvsrc_x, uvsrc_y << field_based,
1597  h_edge_pos >> 1, v_edge_pos >> 1);
1598  s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
1599  uvlinesize >> field_based,uvlinesize >> field_based,
1600  9, 9 + field_based,
1601  uvsrc_x, uvsrc_y << field_based,
1602  h_edge_pos >> 1, v_edge_pos >> 1);
1603  ptr_cb = ubuf;
1604  ptr_cr = vbuf;
1605  }
1606  }
1607 
1608  // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
1609  if (bottom_field) {
1610  dest_y += s->linesize;
1611  dest_cb += s->uvlinesize;
1612  dest_cr += s->uvlinesize;
1613  }
1614 
1615  if (field_select) {
1616  ptr_y += s->linesize;
1617  ptr_cb += s->uvlinesize;
1618  ptr_cr += s->uvlinesize;
1619  }
1620 
1621  sx = (sx << 2) >> lowres;
1622  sy = (sy << 2) >> lowres;
1623  pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1624 
1625  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1626  int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
1627  uvsx = (uvsx << 2) >> lowres;
1628  uvsy = (uvsy << 2) >> lowres;
1629  if (hc) {
1630  pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1631  pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1632  }
1633  }
1634  // FIXME h261 lowres loop filter
1635 }
1636 
1638  uint8_t *dest_cb, uint8_t *dest_cr,
1639  uint8_t **ref_picture,
1640  h264_chroma_mc_func * pix_op,
1641  int mx, int my)
1642 {
1643  const int lowres = s->avctx->lowres;
1644  const int op_index = FFMIN(lowres, 3);
1645  const int block_s = 8 >> lowres;
1646  const int s_mask = (2 << lowres) - 1;
1647  const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1648  const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1649  int emu = 0, src_x, src_y, sx, sy;
1650  ptrdiff_t offset;
1651  uint8_t *ptr;
1652 
1653  if (s->quarter_sample) {
1654  mx /= 2;
1655  my /= 2;
1656  }
1657 
1658  /* In case of 8X8, we construct a single chroma motion vector
1659  with a special rounding */
1660  mx = ff_h263_round_chroma(mx);
1661  my = ff_h263_round_chroma(my);
1662 
1663  sx = mx & s_mask;
1664  sy = my & s_mask;
1665  src_x = s->mb_x * block_s + (mx >> lowres + 1);
1666  src_y = s->mb_y * block_s + (my >> lowres + 1);
1667 
1668  offset = src_y * s->uvlinesize + src_x;
1669  ptr = ref_picture[1] + offset;
1670  if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1671  (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1672  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1673  s->uvlinesize, s->uvlinesize,
1674  9, 9,
1675  src_x, src_y, h_edge_pos, v_edge_pos);
1676  ptr = s->sc.edge_emu_buffer;
1677  emu = 1;
1678  }
1679  sx = (sx << 2) >> lowres;
1680  sy = (sy << 2) >> lowres;
1681  pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1682 
1683  ptr = ref_picture[2] + offset;
1684  if (emu) {
1685  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1686  s->uvlinesize, s->uvlinesize,
1687  9, 9,
1688  src_x, src_y, h_edge_pos, v_edge_pos);
1689  ptr = s->sc.edge_emu_buffer;
1690  }
1691  pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1692 }
1693 
1694 /**
1695  * motion compensation of a single macroblock
1696  * @param s context
1697  * @param dest_y luma destination pointer
1698  * @param dest_cb chroma cb/u destination pointer
1699  * @param dest_cr chroma cr/v destination pointer
1700  * @param dir direction (0->forward, 1->backward)
1701  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1702  * @param pix_op halfpel motion compensation function (average or put normally)
1703  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1704  */
1705 static inline void MPV_motion_lowres(MpegEncContext *s,
1706  uint8_t *dest_y, uint8_t *dest_cb,
1707  uint8_t *dest_cr,
1708  int dir, uint8_t **ref_picture,
1709  h264_chroma_mc_func *pix_op)
1710 {
1711  int mx, my;
1712  int mb_x, mb_y, i;
1713  const int lowres = s->avctx->lowres;
1714  const int block_s = 8 >>lowres;
1715 
1716  mb_x = s->mb_x;
1717  mb_y = s->mb_y;
1718 
1719  switch (s->mv_type) {
1720  case MV_TYPE_16X16:
1721  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1722  0, 0, 0,
1723  ref_picture, pix_op,
1724  s->mv[dir][0][0], s->mv[dir][0][1],
1725  2 * block_s, mb_y);
1726  break;
1727  case MV_TYPE_8X8:
1728  mx = 0;
1729  my = 0;
1730  for (i = 0; i < 4; i++) {
1731  hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
1732  s->linesize) * block_s,
1733  ref_picture[0], 0, 0,
1734  (2 * mb_x + (i & 1)) * block_s,
1735  (2 * mb_y + (i >> 1)) * block_s,
1736  s->width, s->height, s->linesize,
1737  s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1738  block_s, block_s, pix_op,
1739  s->mv[dir][i][0], s->mv[dir][i][1]);
1740 
1741  mx += s->mv[dir][i][0];
1742  my += s->mv[dir][i][1];
1743  }
1744 
1745  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
1746  chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1747  pix_op, mx, my);
1748  break;
1749  case MV_TYPE_FIELD:
1750  if (s->picture_structure == PICT_FRAME) {
1751  /* top field */
1752  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1753  1, 0, s->field_select[dir][0],
1754  ref_picture, pix_op,
1755  s->mv[dir][0][0], s->mv[dir][0][1],
1756  block_s, mb_y);
1757  /* bottom field */
1758  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1759  1, 1, s->field_select[dir][1],
1760  ref_picture, pix_op,
1761  s->mv[dir][1][0], s->mv[dir][1][1],
1762  block_s, mb_y);
1763  } else {
1764  if (s->picture_structure != s->field_select[dir][0] + 1 &&
1765  s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
1766  ref_picture = s->current_picture_ptr->f->data;
1767 
1768  }
1769  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1770  0, 0, s->field_select[dir][0],
1771  ref_picture, pix_op,
1772  s->mv[dir][0][0],
1773  s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1774  }
1775  break;
1776  case MV_TYPE_16X8:
1777  for (i = 0; i < 2; i++) {
1778  uint8_t **ref2picture;
1779 
1780  if (s->picture_structure == s->field_select[dir][i] + 1 ||
1781  s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
1782  ref2picture = ref_picture;
1783  } else {
1784  ref2picture = s->current_picture_ptr->f->data;
1785  }
1786 
1787  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1788  0, 0, s->field_select[dir][i],
1789  ref2picture, pix_op,
1790  s->mv[dir][i][0], s->mv[dir][i][1] +
1791  2 * block_s * i, block_s, mb_y >> 1);
1792 
1793  dest_y += 2 * block_s * s->linesize;
1794  dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1795  dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1796  }
1797  break;
1798  case MV_TYPE_DMV:
1799  if (s->picture_structure == PICT_FRAME) {
1800  for (i = 0; i < 2; i++) {
1801  int j;
1802  for (j = 0; j < 2; j++) {
1803  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1804  1, j, j ^ i,
1805  ref_picture, pix_op,
1806  s->mv[dir][2 * i + j][0],
1807  s->mv[dir][2 * i + j][1],
1808  block_s, mb_y);
1809  }
1810  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1811  }
1812  } else {
1813  for (i = 0; i < 2; i++) {
1814  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1815  0, 0, s->picture_structure != i + 1,
1816  ref_picture, pix_op,
1817  s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
1818  2 * block_s, mb_y >> 1);
1819 
1820  // after put we make avg of the same block
1821  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1822 
1823  // opposite parity is always in the same
1824  // frame if this is second field
1825  if (!s->first_field) {
1826  ref_picture = s->current_picture_ptr->f->data;
1827  }
1828  }
1829  }
1830  break;
1831  default:
1832  av_assert2(0);
1833  }
1834 }
1835 
1836 /**
1837  * find the lowest MB row referenced in the MVs
1838  */
1840 {
1841  int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1842  int my, off, i, mvs;
1843 
1844  if (s->picture_structure != PICT_FRAME || s->mcsel)
1845  goto unhandled;
1846 
1847  switch (s->mv_type) {
1848  case MV_TYPE_16X16:
1849  mvs = 1;
1850  break;
1851  case MV_TYPE_16X8:
1852  mvs = 2;
1853  break;
1854  case MV_TYPE_8X8:
1855  mvs = 4;
1856  break;
1857  default:
1858  goto unhandled;
1859  }
1860 
1861  for (i = 0; i < mvs; i++) {
1862  my = s->mv[dir][i][1];
1863  my_max = FFMAX(my_max, my);
1864  my_min = FFMIN(my_min, my);
1865  }
1866 
1867  off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1868 
1869  return av_clip(s->mb_y + off, 0, s->mb_height - 1);
1870 unhandled:
1871  return s->mb_height-1;
1872 }
1873 
1874 /* put block[] to dest[] */
1875 static inline void put_dct(MpegEncContext *s,
1876  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1877 {
1878  s->dct_unquantize_intra(s, block, i, qscale);
1879  s->idsp.idct_put(dest, line_size, block);
1880 }
1881 
1882 /* add block[] to dest[] */
1883 static inline void add_dct(MpegEncContext *s,
1884  int16_t *block, int i, uint8_t *dest, int line_size)
1885 {
1886  if (s->block_last_index[i] >= 0) {
1887  s->idsp.idct_add(dest, line_size, block);
1888  }
1889 }
1890 
1891 static inline void add_dequant_dct(MpegEncContext *s,
1892  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1893 {
1894  if (s->block_last_index[i] >= 0) {
1895  s->dct_unquantize_inter(s, block, i, qscale);
1896 
1897  s->idsp.idct_add(dest, line_size, block);
1898  }
1899 }
1900 
1901 /**
1902  * Clean dc, ac, coded_block for the current non-intra MB.
1903  */
1905 {
1906  int wrap = s->b8_stride;
1907  int xy = s->block_index[0];
1908 
1909  s->dc_val[0][xy ] =
1910  s->dc_val[0][xy + 1 ] =
1911  s->dc_val[0][xy + wrap] =
1912  s->dc_val[0][xy + 1 + wrap] = 1024;
1913  /* ac pred */
1914  memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1915  memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1916  if (s->msmpeg4_version>=3) {
1917  s->coded_block[xy ] =
1918  s->coded_block[xy + 1 ] =
1919  s->coded_block[xy + wrap] =
1920  s->coded_block[xy + 1 + wrap] = 0;
1921  }
1922  /* chroma */
1923  wrap = s->mb_stride;
1924  xy = s->mb_x + s->mb_y * wrap;
1925  s->dc_val[1][xy] =
1926  s->dc_val[2][xy] = 1024;
1927  /* ac pred */
1928  memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1929  memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1930 
1931  s->mbintra_table[xy]= 0;
1932 }
1933 
1934 /* generic function called after a macroblock has been parsed by the
1935  decoder or after it has been encoded by the encoder.
1936 
1937  Important variables used:
1938  s->mb_intra : true if intra macroblock
1939  s->mv_dir : motion vector direction
1940  s->mv_type : motion vector type
1941  s->mv : motion vector
1942  s->interlaced_dct : true if interlaced dct used (mpeg2)
1943  */
1944 static av_always_inline
1946  int lowres_flag, int is_mpeg12)
1947 {
1948  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1949 
1950  if (CONFIG_XVMC &&
1951  s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
1952  s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
1953  return;
1954  }
1955 
1956  if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1957  /* print DCT coefficients */
1958  int i,j;
1959  av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1960  for(i=0; i<6; i++){
1961  for(j=0; j<64; j++){
1962  av_log(s->avctx, AV_LOG_DEBUG, "%5d",
1963  block[i][s->idsp.idct_permutation[j]]);
1964  }
1965  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1966  }
1967  }
1968 
1969  s->current_picture.qscale_table[mb_xy] = s->qscale;
1970 
1971  /* update DC predictors for P macroblocks */
1972  if (!s->mb_intra) {
1973  if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1974  if(s->mbintra_table[mb_xy])
1976  } else {
1977  s->last_dc[0] =
1978  s->last_dc[1] =
1979  s->last_dc[2] = 128 << s->intra_dc_precision;
1980  }
1981  }
1982  else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1983  s->mbintra_table[mb_xy]=1;
1984 
1985  if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
1986  !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
1987  s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
1988  uint8_t *dest_y, *dest_cb, *dest_cr;
1989  int dct_linesize, dct_offset;
1990  op_pixels_func (*op_pix)[4];
1991  qpel_mc_func (*op_qpix)[16];
1992  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
1993  const int uvlinesize = s->current_picture.f->linesize[1];
1994  const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1995  const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1996 
1997  /* avoid copy if macroblock skipped in last frame too */
1998  /* skip only during decoding as we might trash the buffers during encoding a bit */
1999  if(!s->encoding){
2000  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2001 
2002  if (s->mb_skipped) {
2003  s->mb_skipped= 0;
2004  av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2005  *mbskip_ptr = 1;
2006  } else if(!s->current_picture.reference) {
2007  *mbskip_ptr = 1;
2008  } else{
2009  *mbskip_ptr = 0; /* not skipped */
2010  }
2011  }
2012 
2013  dct_linesize = linesize << s->interlaced_dct;
2014  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2015 
2016  if(readable){
2017  dest_y= s->dest[0];
2018  dest_cb= s->dest[1];
2019  dest_cr= s->dest[2];
2020  }else{
2021  dest_y = s->sc.b_scratchpad;
2022  dest_cb= s->sc.b_scratchpad+16*linesize;
2023  dest_cr= s->sc.b_scratchpad+32*linesize;
2024  }
2025 
2026  if (!s->mb_intra) {
2027  /* motion handling */
2028  /* decoding or more than one mb_type (MC was already done otherwise) */
2029  if(!s->encoding){
2030 
2031  if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2032  if (s->mv_dir & MV_DIR_FORWARD) {
2033  ff_thread_await_progress(&s->last_picture_ptr->tf,
2035  0);
2036  }
2037  if (s->mv_dir & MV_DIR_BACKWARD) {
2038  ff_thread_await_progress(&s->next_picture_ptr->tf,
2040  0);
2041  }
2042  }
2043 
2044  if(lowres_flag){
2045  h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2046 
2047  if (s->mv_dir & MV_DIR_FORWARD) {
2048  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2049  op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2050  }
2051  if (s->mv_dir & MV_DIR_BACKWARD) {
2052  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2053  }
2054  }else{
2055  op_qpix = s->me.qpel_put;
2056  if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2057  op_pix = s->hdsp.put_pixels_tab;
2058  }else{
2059  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2060  }
2061  if (s->mv_dir & MV_DIR_FORWARD) {
2062  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2063  op_pix = s->hdsp.avg_pixels_tab;
2064  op_qpix= s->me.qpel_avg;
2065  }
2066  if (s->mv_dir & MV_DIR_BACKWARD) {
2067  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2068  }
2069  }
2070  }
2071 
2072  /* skip dequant / idct if we are really late ;) */
2073  if(s->avctx->skip_idct){
2074  if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2075  ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2076  || s->avctx->skip_idct >= AVDISCARD_ALL)
2077  goto skip_idct;
2078  }
2079 
2080  /* add dct residue */
2081  if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2082  || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2083  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2084  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2085  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2086  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2087 
2088  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2089  if (s->chroma_y_shift){
2090  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2091  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2092  }else{
2093  dct_linesize >>= 1;
2094  dct_offset >>=1;
2095  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2096  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2097  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2098  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2099  }
2100  }
2101  } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2102  add_dct(s, block[0], 0, dest_y , dct_linesize);
2103  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2104  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2105  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2106 
2107  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2108  if(s->chroma_y_shift){//Chroma420
2109  add_dct(s, block[4], 4, dest_cb, uvlinesize);
2110  add_dct(s, block[5], 5, dest_cr, uvlinesize);
2111  }else{
2112  //chroma422
2113  dct_linesize = uvlinesize << s->interlaced_dct;
2114  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2115 
2116  add_dct(s, block[4], 4, dest_cb, dct_linesize);
2117  add_dct(s, block[5], 5, dest_cr, dct_linesize);
2118  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2119  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2120  if(!s->chroma_x_shift){//Chroma444
2121  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2122  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2123  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2124  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2125  }
2126  }
2127  }//fi gray
2128  }
2129  else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2130  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2131  }
2132  } else {
2133  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
2134  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
2135  if (s->avctx->bits_per_raw_sample > 8){
2136  const int act_block_size = block_size * 2;
2137 
2138  if(s->dpcm_direction == 0) {
2139  s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)(*s->block32)[0]);
2140  s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)(*s->block32)[1]);
2141  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)(*s->block32)[2]);
2142  s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)(*s->block32)[3]);
2143 
2144  dct_linesize = uvlinesize << s->interlaced_dct;
2145  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2146 
2147  s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)(*s->block32)[4]);
2148  s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)(*s->block32)[5]);
2149  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)(*s->block32)[6]);
2150  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)(*s->block32)[7]);
2151  if(!s->chroma_x_shift){//Chroma444
2152  s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)(*s->block32)[8]);
2153  s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)(*s->block32)[9]);
2154  s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[10]);
2155  s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[11]);
2156  }
2157  } else if(s->dpcm_direction == 1) {
2158  int i, w, h;
2159  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2160  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2161  for(i = 0; i < 3; i++) {
2162  int idx = 0;
2163  int vsub = i ? s->chroma_y_shift : 0;
2164  int hsub = i ? s->chroma_x_shift : 0;
2165  for(h = 0; h < (16 >> vsub); h++){
2166  for(w = 0; w < (16 >> hsub); w++)
2167  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2168  dest_pcm[i] += linesize[i] / 2;
2169  }
2170  }
2171  } else if(s->dpcm_direction == -1) {
2172  int i, w, h;
2173  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2174  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2175  for(i = 0; i < 3; i++) {
2176  int idx = 0;
2177  int vsub = i ? s->chroma_y_shift : 0;
2178  int hsub = i ? s->chroma_x_shift : 0;
2179  dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub) - 1);
2180  for(h = (16 >> vsub)-1; h >= 1; h--){
2181  for(w = (16 >> hsub)-1; w >= 1; w--)
2182  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2183  dest_pcm[i] -= linesize[i] / 2;
2184  }
2185  }
2186  }
2187  }
2188  /* dct only in intra block */
2189  else if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2190  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2191  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2192  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2193  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2194 
2195  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2196  if(s->chroma_y_shift){
2197  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2198  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2199  }else{
2200  dct_offset >>=1;
2201  dct_linesize >>=1;
2202  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2203  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2204  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2205  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2206  }
2207  }
2208  }else{
2209  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
2210  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2211  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
2212  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2213 
2214  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2215  if(s->chroma_y_shift){
2216  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2217  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2218  }else{
2219 
2220  dct_linesize = uvlinesize << s->interlaced_dct;
2221  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2222 
2223  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
2224  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
2225  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2226  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2227  if(!s->chroma_x_shift){//Chroma444
2228  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2229  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2230  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2231  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2232  }
2233  }
2234  }//gray
2235  }
2236  }
2237 skip_idct:
2238  if(!readable){
2239  s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2240  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2241  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2242  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2243  }
2244  }
2245  }
2246 }
2247 
2249 {
2250 #if !CONFIG_SMALL
2251  if(s->out_format == FMT_MPEG1) {
2252  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
2253  else mpv_reconstruct_mb_internal(s, block, 0, 1);
2254  } else
2255 #endif
2256  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
2257  else mpv_reconstruct_mb_internal(s, block, 0, 0);
2258 }
2259 
2261 {
2262  ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
2263  s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
2264  s->first_field, s->low_delay);
2265 }
2266 
2267 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2268  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2269  const int uvlinesize = s->current_picture.f->linesize[1];
2270  const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
2271  const int height_of_mb = 4 - s->avctx->lowres;
2272 
2273  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2274  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2275  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2276  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2277  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2278  s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2279  //block_index is not used by mpeg2, so it is not affected by chroma_format
2280 
2281  s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);
2282  s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2283  s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2284 
2285  if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2286  {
2287  if(s->picture_structure==PICT_FRAME){
2288  s->dest[0] += s->mb_y * linesize << height_of_mb;
2289  s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2290  s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2291  }else{
2292  s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
2293  s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2294  s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2295  av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2296  }
2297  }
2298 }
2299 
2301  int i;
2302  MpegEncContext *s = avctx->priv_data;
2303 
2304  if (!s || !s->picture)
2305  return;
2306 
2307  for (i = 0; i < MAX_PICTURE_COUNT; i++)
2308  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2309  s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2310 
2311  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
2312  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
2313  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
2314 
2315  s->mb_x= s->mb_y= 0;
2316  s->closed_gop= 0;
2317 
2318  s->parse_context.state= -1;
2319  s->parse_context.frame_start_found= 0;
2320  s->parse_context.overread= 0;
2321  s->parse_context.overread_index= 0;
2322  s->parse_context.index= 0;
2323  s->parse_context.last_index= 0;
2324  s->bitstream_buffer_size=0;
2325  s->pp_time=0;
2326 }
2327 
2328 /**
2329  * set qscale and update qscale dependent variables.
2330  */
2331 void ff_set_qscale(MpegEncContext * s, int qscale)
2332 {
2333  if (qscale < 1)
2334  qscale = 1;
2335  else if (qscale > 31)
2336  qscale = 31;
2337 
2338  s->qscale = qscale;
2339  s->chroma_qscale= s->chroma_qscale_table[qscale];
2340 
2341  s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2342  s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2343 }
2344 
2346 {
2347  if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2348  ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2349 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:103
ff_h263_round_chroma
static int ff_h263_round_chroma(int x)
Definition: motion_est.h:101
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:39
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:913
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1465
stride
int stride
Definition: mace.c:144
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
free_duplicate_contexts
static void free_duplicate_contexts(MpegEncContext *s)
Definition: mpegvideo.c:460
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:122
ff_mpeg_framesize_alloc
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:58
blockdsp.h
FMT_MPEG1
@ FMT_MPEG1
Definition: mpegutils.h:124
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecContext::workaround_bugs
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:1357
mpeg_motion_lowres
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h, int mb_y)
Definition: mpegvideo.c:1498
backup_duplicate_context
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
Definition: mpegvideo.c:469
ff_mpv_common_defaults
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
Definition: mpegvideo.c:676
hpel_motion_lowres
static int hpel_motion_lowres(MpegEncContext *s, uint8_t *dest, uint8_t *src, int field_based, int field_select, int src_x, int src_y, int width, int height, ptrdiff_t stride, int h_edge_pos, int v_edge_pos, int w, int h, h264_chroma_mc_func *pix_op, int motion_x, int motion_y)
Definition: mpegvideo.c:1451
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:975
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:268
AVFrame::coded_picture_number
int coded_picture_number
picture number in bitstream order
Definition: frame.h:408
Picture::alloc_mb_width
int alloc_mb_width
mb_width used to allocate tables
Definition: mpegpicture.h:70
lowest_referenced_row
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo.c:1839
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:858
ff_mpv_common_frame_size_change
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1055
w
uint8_t w
Definition: llviddspenc.c:39
internal.h
ff_free_picture_tables
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:454
last_picture
enum AVPictureType last_picture
Definition: movenc.c:69
b
#define b
Definition: input.c:41
ff_mpeg2_non_linear_qscale
const uint8_t ff_mpeg2_non_linear_qscale[32]
Definition: mpegvideodata.c:26
REBASE_PICTURE
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:1904
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
init_duplicate_context
static int init_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:359
ff_mpv_common_init_arm
av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
Definition: mpegvideo_arm.c:44
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2267
mpegvideo.h
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:289
Picture
Picture.
Definition: mpegpicture.h:45
AV_CODEC_FLAG_INTERLACED_ME
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:319
mpegutils.h
thread.h
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
free_duplicate_context
static void free_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:438
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:270
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:75
mpv_reconstruct_mb_internal
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpegvideo.c:1945
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:291
chroma_4mv_motion_lowres
static void chroma_4mv_motion_lowres(MpegEncContext *s, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int mx, int my)
Definition: mpegvideo.c:1637
AV_VIDEO_ENC_PARAMS_MPEG2
@ AV_VIDEO_ENC_PARAMS_MPEG2
Definition: video_enc_params.h:65
dct_unquantize_mpeg1_inter_c
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:83
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:510
U
#define U(x)
Definition: vp56_arith.h:37
fail
#define fail()
Definition: checkasm.h:134
wrap
#define wrap(func)
Definition: neontest.h:65
h264_chroma_mc_func
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
MpegEncContext::linesize
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
ff_print_debug_info2
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:103
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2260
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:33
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2569
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:102
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:689
AVVideoEncParams
Video encoding parameters for a given frame.
Definition: video_enc_params.h:73
MAX_PICTURE_COUNT
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
dct_unquantize_mpeg1_intra_c
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:54
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:56
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1111
MpegEncContext::pblocks
int16_t(*[12] pblocks)[64]
Definition: mpegvideo.h:508
avassert.h
gray16
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:271
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:587
motion_vector.h
width
#define width
add_dct
static void add_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size)
Definition: mpegvideo.c:1883
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_mpeg_unref_picture
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:295
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
UPDATE_PICTURE
#define UPDATE_PICTURE(pic)
s1
#define s1
Definition: regdef.h:38
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:67
dct_unquantize_mpeg2_intra_bitexact
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:142
FMT_H261
@ FMT_H261
Definition: mpegutils.h:125
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
limits.h
ff_mpegvideodsp_init
av_cold void ff_mpegvideodsp_init(MpegVideoDSPContext *c)
Definition: mpegvideodsp.c:110
f
#define f(width, name)
Definition: cbs_vp9.c:255
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
Picture::reference
int reference
Definition: mpegpicture.h:88
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:213
ff_find_unused_picture
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:440
NULL
#define NULL
Definition: coverity.c:32
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
me
#define me
Definition: vf_colormatrix.c:104
put_dct
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1875
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2331
mathops.h
FF_BUG_IEDGE
#define FF_BUG_IEDGE
Definition: avcodec.h:1372
lowres
static int lowres
Definition: ffplay.c:336
qpeldsp.h
ff_alternate_horizontal_scan
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:84
MpegEncContext::me
MotionEstContext me
Definition: mpegvideo.h:282
ff_alloc_picture
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
Definition: mpegpicture.c:232
ME_MAP_SIZE
#define ME_MAP_SIZE
Definition: motion_est.h:38
op_pixels_func
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
wmv2.h
qpel_mc_func
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
dct_unquantize_mpeg2_intra_c
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:112
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:267
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
av_video_enc_params_create_side_data
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
Definition: video_enc_params.c:56
FF_DEBUG_DCT_COEFF
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:1414
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:212
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:285
ff_mpeg_ref_picture
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:355
FF_QSCALE_TYPE_MPEG1
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:97
ff_draw_horiz_band
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:51
ff_mpeg_er_init
int ff_mpeg_er_init(MpegEncContext *s)
Definition: mpeg_er.c:100
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
ff_mpv_motion
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
Definition: mpegvideo_motion.c:974
alloc_picture
static int alloc_picture(MpegEncContext *s, Picture *pic)
Definition: mpegvideo.c:351
h264chroma.h
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1558
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2300
Picture::alloc_mb_height
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:71
height
#define height
init_context_frame
static int init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:716
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:524
mpegvideodata.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1420
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1413
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
dct_unquantize_mpeg2_inter_c
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:176
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1557
clear_context
static void clear_context(MpegEncContext *s)
Definition: mpegvideo.c:831
AVCodec::id
enum AVCodecID id
Definition: codec.h:211
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
FMT_H263
@ FMT_H263
Definition: mpegutils.h:126
i
int i
Definition: input.c:407
dct_unquantize_h263_inter_c
static void dct_unquantize_h263_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:244
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:95
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
internal.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
ff_mpv_common_init_ppc
void ff_mpv_common_init_ppc(MpegEncContext *s)
Definition: mpegvideo_altivec.c:119
av_always_inline
#define av_always_inline
Definition: attributes.h:49
MpegEncContext::sc
ScratchpadContext sc
Definition: mpegvideo.h:202
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVVideoBlockParams
Data structure for storing block-level encoding information.
Definition: video_enc_params.h:120
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:243
ff_wmv2_add_mb
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2.c:83
AVCodecContext::height
int height
Definition: avcodec.h:674
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1405
FF_DEBUG_NOMC
#define FF_DEBUG_NOMC
Definition: avcodec.h:1423
idctdsp.h
avcodec.h
msmpeg4.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
Picture::qscale_table
int8_t * qscale_table
Definition: mpegpicture.h:50
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1181
free_context_frame
static void free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution as well as the slice thread contex...
Definition: mpegvideo.c:1004
dct_init
static av_cold int dct_init(MpegEncContext *s)
Definition: mpegvideo.c:284
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:192
AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:389
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
MpegEncContext::block
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:510
AVCodecContext
main external API structure.
Definition: avcodec.h:501
ScratchpadContext::edge_emu_buffer
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:499
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:46
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
dct_unquantize_h263_intra_c
static void dct_unquantize_h263_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:210
ff_mpv_common_init_x86
av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
Definition: mpegvideo.c:454
MPV_motion_lowres
static void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, h264_chroma_mc_func *pix_op)
motion compensation of a single macroblock
Definition: mpegvideo.c:1705
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2248
ff_mpv_common_init_axp
av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
Definition: mpegvideo_alpha.c:106
FF_MB_DECISION_RD
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:965
ff_mpv_common_init_mips
av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
Definition: mpegvideo_init_mips.c:26
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:689
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
init_duplicate_contexts
static int init_duplicate_contexts(MpegEncContext *s)
Initialize an MpegEncContext's thread contexts.
Definition: mpegvideo.c:414
ff_default_chroma_qscale_table
const uint8_t ff_default_chroma_qscale_table[32]
Definition: mpegvideodata.c:21
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:310
COPY
#define COPY(a)
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:526
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:508
mpeg_er.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:674
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2345
add_dequant_dct
static void add_dequant_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1891
av_video_enc_params_block
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
Definition: video_enc_params.h:143
h
h
Definition: vp9dsp_template.c:2038
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:315
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:70
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:699
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:209
int
int
Definition: ffmpeg_filter.c:156
mjpegenc.h
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
ff_mpv_common_init_neon
av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
Definition: mpegvideo.c:127
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
gray8
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:277
gray_frame
static void gray_frame(AVFrame *frame)
Definition: mpegvideo.c:1161
Picture::alloc_mb_stride
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:72
video_enc_params.h