Go to the documentation of this file.
47 int16_t *
block,
int n,
int qscale)
50 const uint16_t *quant_matrix;
52 nCoeffs=
s->block_last_index[n];
54 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
56 quant_matrix =
s->intra_matrix;
57 for(
i=1;
i<=nCoeffs;
i++) {
58 int j=
s->intra_scantable.permutated[
i];
76 int16_t *
block,
int n,
int qscale)
79 const uint16_t *quant_matrix;
81 nCoeffs=
s->block_last_index[n];
83 quant_matrix =
s->inter_matrix;
84 for(
i=0;
i<=nCoeffs;
i++) {
85 int j=
s->intra_scantable.permutated[
i];
91 ((
int) (quant_matrix[j]))) >> 4;
96 ((
int) (quant_matrix[j]))) >> 4;
105 int16_t *
block,
int n,
int qscale)
108 const uint16_t *quant_matrix;
113 if(
s->alternate_scan) nCoeffs= 63;
114 else nCoeffs=
s->block_last_index[n];
116 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
117 quant_matrix =
s->intra_matrix;
118 for(
i=1;
i<=nCoeffs;
i++) {
119 int j=
s->intra_scantable.permutated[
i];
135 int16_t *
block,
int n,
int qscale)
138 const uint16_t *quant_matrix;
144 if(
s->alternate_scan) nCoeffs= 63;
145 else nCoeffs=
s->block_last_index[n];
147 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
149 quant_matrix =
s->intra_matrix;
150 for(
i=1;
i<=nCoeffs;
i++) {
151 int j=
s->intra_scantable.permutated[
i];
169 int16_t *
block,
int n,
int qscale)
172 const uint16_t *quant_matrix;
178 if(
s->alternate_scan) nCoeffs= 63;
179 else nCoeffs=
s->block_last_index[n];
181 quant_matrix =
s->inter_matrix;
182 for(
i=0;
i<=nCoeffs;
i++) {
183 int j=
s->intra_scantable.permutated[
i];
189 ((
int) (quant_matrix[j]))) >> 5;
193 ((
int) (quant_matrix[j]))) >> 5;
203 int16_t *
block,
int n,
int qscale)
213 block[0] *= n < 4 ?
s->y_dc_scale :
s->c_dc_scale;
214 qadd = (qscale - 1) | 1;
221 nCoeffs=
s->intra_scantable.raster_end[
s->block_last_index[n] ];
223 for(
i=1;
i<=nCoeffs;
i++) {
237 int16_t *
block,
int n,
int qscale)
244 qadd = (qscale - 1) | 1;
247 nCoeffs=
s->inter_scantable.raster_end[
s->block_last_index[n] ];
249 for(
i=0;
i<=nCoeffs;
i++) {
263 static void gray16(uint8_t *dst,
const uint8_t *
src, ptrdiff_t linesize,
int h)
266 memset(dst +
h*linesize, 128, 16);
269 static void gray8(uint8_t *dst,
const uint8_t *
src, ptrdiff_t linesize,
int h)
272 memset(dst +
h*linesize, 128, 8);
284 for (
i=0;
i<4;
i++) {
285 s->hdsp.avg_pixels_tab[0][
i] =
gray16;
286 s->hdsp.put_pixels_tab[0][
i] =
gray16;
287 s->hdsp.put_no_rnd_pixels_tab[0][
i] =
gray16;
289 s->hdsp.avg_pixels_tab[1][
i] =
gray8;
290 s->hdsp.put_pixels_tab[1][
i] =
gray8;
291 s->hdsp.put_no_rnd_pixels_tab[1][
i] =
gray8;
304 #if HAVE_INTRINSICS_NEON
322 const uint8_t *src_scantable)
328 for (
int i = 0;
i < 64;
i++) {
329 int j = src_scantable[
i];
334 for (
int i = 0;
i < 64;
i++) {
345 s->idsp.mpeg4_studio_profile =
s->studio_profile;
351 if (
s->alternate_scan) {
359 s->idsp.idct_permutation);
361 s->idsp.idct_permutation);
372 if (
s->noise_reduction) {
379 s->block =
s->blocks[0];
382 int mb_height =
s->msmpeg4_version == MSMP4_VC1 ?
384 int y_size =
s->b8_stride * (2 * mb_height + 1);
385 int c_size =
s->mb_stride * (mb_height + 1);
386 int yc_size = y_size + 2 * c_size;
390 s->ac_val[0] =
s->ac_val_base +
s->b8_stride + 1;
391 s->ac_val[1] =
s->ac_val_base + y_size +
s->mb_stride + 1;
392 s->ac_val[2] =
s->ac_val[1] + c_size;
400 int nb_slices =
s->slice_context_count,
ret;
405 for (
int i = 1;
i < nb_slices;
i++) {
407 if (!
s->thread_context[
i])
411 s->thread_context[
i]->start_mb_y =
412 (
s->mb_height * (
i ) + nb_slices / 2) / nb_slices;
413 s->thread_context[
i]->end_mb_y =
414 (
s->mb_height * (
i + 1) + nb_slices / 2) / nb_slices;
417 s->end_mb_y = nb_slices > 1 ? (
s->mb_height + nb_slices / 2) / nb_slices
429 s->me.temp =
s->me.scratchpad =
430 s->sc.obmc_scratchpad =
NULL;
435 s->me.score_map =
NULL;
443 for (
int i = 1;
i <
s->slice_context_count;
i++) {
452 #define COPY(a) bak->a = src->a
483 "scratch buffers.\n");
497 s->y_dc_scale_table =
500 s->progressive_frame = 1;
501 s->progressive_sequence = 1;
504 s->picture_number = 0;
509 s->slice_context_count = 1;
525 int y_size, c_size, yc_size,
i, mb_array_size, mv_table_size, x, y;
529 s->mb_height = (
s->height + 31) / 32 * 2;
531 s->mb_height = (
s->height + 15) / 16;
536 mb_height =
s->msmpeg4_version == MSMP4_VC1 ?
539 s->mb_width = (
s->width + 15) / 16;
540 s->mb_stride =
s->mb_width + 1;
541 s->b8_stride =
s->mb_width * 2 + 1;
542 mb_array_size = mb_height *
s->mb_stride;
543 mv_table_size = (mb_height + 2) *
s->mb_stride + 1;
547 s->h_edge_pos =
s->mb_width * 16;
548 s->v_edge_pos =
s->mb_height * 16;
550 s->mb_num =
s->mb_width *
s->mb_height;
555 s->block_wrap[3] =
s->b8_stride;
557 s->block_wrap[5] =
s->mb_stride;
559 y_size =
s->b8_stride * (2 * mb_height + 1);
560 c_size =
s->mb_stride * (mb_height + 1);
561 yc_size = y_size + 2 * c_size;
565 for (y = 0; y <
s->mb_height; y++)
566 for (x = 0; x <
s->mb_width; x++)
567 s->mb_index2xy[x + y *
s->mb_width] = x + y *
s->mb_stride;
569 s->mb_index2xy[
s->mb_height *
s->mb_width] = (
s->mb_height - 1) *
s->mb_stride +
s->mb_width;
571 #define ALLOC_POOL(name, size, flags) do { \
572 pools->name ##_pool = ff_refstruct_pool_alloc((size), (flags)); \
573 if (!pools->name ##_pool) \
574 return AVERROR(ENOMEM); \
583 s->p_field_mv_table_base =
tmp;
584 tmp +=
s->mb_stride + 1;
585 for (
int i = 0;
i < 2;
i++) {
586 for (
int j = 0; j < 2; j++) {
587 s->p_field_mv_table[
i][j] =
tmp;
588 tmp += mv_table_size;
603 if (
s->msmpeg4_version >= MSMP4_V3) {
605 if (!
s->coded_block_base)
607 s->coded_block =
s->coded_block_base +
s->b8_stride + 1;
610 if (
s->h263_pred ||
s->h263_plus || !
s->encoding) {
615 s->dc_val[0] =
s->dc_val_base +
s->b8_stride + 1;
616 s->dc_val[1] =
s->dc_val_base + y_size +
s->mb_stride + 1;
617 s->dc_val[2] =
s->dc_val[1] + c_size;
618 for (
i = 0;
i < yc_size;
i++)
619 s->dc_val_base[
i] = 1024;
623 if (!(
s->mbskip_table =
av_mallocz(mb_array_size + 2)) ||
625 !(
s->mbintra_table =
av_malloc(mb_array_size)))
627 memset(
s->mbintra_table, 1, mb_array_size);
630 ALLOC_POOL(mb_type, mv_table_size *
sizeof(uint32_t), 0);
632 if (
s->out_format ==
FMT_H263 ||
s->encoding ||
634 const int b8_array_size =
s->b8_stride * mb_height * 2;
635 int mv_size = 2 * (b8_array_size + 4) *
sizeof(int16_t);
636 int ref_index_size = 4 * mb_array_size;
654 memset(&
s->buffer_pools, 0,
sizeof(
s->buffer_pools));
655 memset(&
s->next_pic, 0,
sizeof(
s->next_pic));
656 memset(&
s->last_pic, 0,
sizeof(
s->last_pic));
657 memset(&
s->cur_pic, 0,
sizeof(
s->cur_pic));
659 memset(
s->thread_context, 0,
sizeof(
s->thread_context));
662 s->me.score_map =
NULL;
663 s->dct_error_sum =
NULL;
666 s->ac_val_base =
NULL;
670 s->me.scratchpad =
NULL;
672 memset(&
s->sc, 0,
sizeof(
s->sc));
675 s->bitstream_buffer =
NULL;
676 s->allocated_bitstream_buffer_size = 0;
677 s->p_field_mv_table_base =
NULL;
678 for (
int i = 0;
i < 2;
i++)
679 for (
int j = 0; j < 2; j++)
680 s->p_field_mv_table[
i][j] =
NULL;
682 s->dc_val_base =
NULL;
683 s->coded_block_base =
NULL;
684 s->mbintra_table =
NULL;
686 s->pred_dir_table =
NULL;
688 s->mbskip_table =
NULL;
690 s->er.error_status_table =
NULL;
691 s->er.er_temp_buffer =
NULL;
692 s->mb_index2xy =
NULL;
701 int nb_slices = (HAVE_THREADS &&
703 s->avctx->thread_count : 1;
708 if (
s->encoding &&
s->avctx->slices)
709 nb_slices =
s->avctx->slices;
713 "decoding to AV_PIX_FMT_NONE is not supported.\n");
717 if ((
s->width ||
s->height) &&
733 if (nb_slices >
MAX_THREADS || (nb_slices >
s->mb_height &&
s->mb_height)) {
740 " reducing to %d\n", nb_slices, max_slices);
741 nb_slices = max_slices;
744 s->context_initialized = 1;
745 memset(
s->thread_context, 0,
sizeof(
s->thread_context));
746 s->thread_context[0] =
s;
747 s->slice_context_count = nb_slices;
767 for (
int i = 0;
i < 2;
i++)
768 for (
int j = 0; j < 2; j++)
769 s->p_field_mv_table[
i][j] =
NULL;
783 s->linesize =
s->uvlinesize = 0;
789 if (
s->slice_context_count > 1)
790 s->slice_context_count = 1;
793 s->allocated_bitstream_buffer_size = 0;
799 s->context_initialized = 0;
800 s->context_reinit = 0;
801 s->linesize =
s->uvlinesize = 0;
810 int wrap =
s->b8_stride;
811 int xy =
s->block_index[0];
814 s->dc_val[0][xy + 1 ] =
815 s->dc_val[0][xy +
wrap] =
816 s->dc_val[0][xy + 1 +
wrap] = 1024;
818 memset(
s->ac_val[0][xy ], 0, 32 *
sizeof(int16_t));
819 memset(
s->ac_val[0][xy +
wrap], 0, 32 *
sizeof(int16_t));
822 xy =
s->mb_x +
s->mb_y *
wrap;
824 s->dc_val[2][xy] = 1024;
826 memset(
s->ac_val[1][xy], 0, 16 *
sizeof(int16_t));
827 memset(
s->ac_val[2][xy], 0, 16 *
sizeof(int16_t));
829 s->mbintra_table[xy]= 0;
833 const int linesize =
s->cur_pic.linesize[0];
834 const int uvlinesize =
s->cur_pic.linesize[1];
835 const int width_of_mb = (4 + (
s->avctx->bits_per_raw_sample > 8)) -
s->avctx->lowres;
836 const int height_of_mb = 4 -
s->avctx->lowres;
838 s->block_index[0]=
s->b8_stride*(
s->mb_y*2 ) - 2 +
s->mb_x*2;
839 s->block_index[1]=
s->b8_stride*(
s->mb_y*2 ) - 1 +
s->mb_x*2;
840 s->block_index[2]=
s->b8_stride*(
s->mb_y*2 + 1) - 2 +
s->mb_x*2;
841 s->block_index[3]=
s->b8_stride*(
s->mb_y*2 + 1) - 1 +
s->mb_x*2;
842 s->block_index[4]=
s->mb_stride*(
s->mb_y + 1) +
s->b8_stride*
s->mb_height*2 +
s->mb_x - 1;
843 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;
846 s->dest[0] =
s->cur_pic.data[0] + (
int)((
s->mb_x - 1
U) << width_of_mb);
847 s->dest[1] =
s->cur_pic.data[1] + (
int)((
s->mb_x - 1
U) << (width_of_mb -
s->chroma_x_shift));
848 s->dest[2] =
s->cur_pic.data[2] + (
int)((
s->mb_x - 1
U) << (width_of_mb -
s->chroma_x_shift));
851 s->dest[0] +=
s->mb_y * linesize << height_of_mb;
852 s->dest[1] +=
s->mb_y * uvlinesize << (height_of_mb -
s->chroma_y_shift);
853 s->dest[2] +=
s->mb_y * uvlinesize << (height_of_mb -
s->chroma_y_shift);
855 s->dest[0] += (
s->mb_y>>1) * linesize << height_of_mb;
856 s->dest[1] += (
s->mb_y>>1) * uvlinesize << (height_of_mb -
s->chroma_y_shift);
857 s->dest[2] += (
s->mb_y>>1) * uvlinesize << (height_of_mb -
s->chroma_y_shift);
869 else if (qscale > 31)
873 s->chroma_qscale=
s->chroma_qscale_table[qscale];
875 s->y_dc_scale=
s->y_dc_scale_table[ qscale ];
876 s->c_dc_scale=
s->c_dc_scale_table[
s->chroma_qscale ];
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
#define AV_LOG_WARNING
Something somehow does not look correct.
static void free_duplicate_contexts(MpegEncContext *s)
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
int ff_mpv_init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src)
const uint8_t ff_mpeg2_non_linear_qscale[32]
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
#define PICT_BOTTOM_FIELD
static int init_duplicate_context(MpegEncContext *s)
av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
void ff_init_block_index(MpegEncContext *s)
struct AVCodecContext * avctx
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
static void free_duplicate_context(MpegEncContext *s)
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
static void ff_refstruct_pool_uninit(FFRefStructPool **poolp)
Mark the pool as being available for freeing.
ptrdiff_t linesize
line size, in bytes, may be different from width
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.
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
struct FFRefStructPool * mb_type_pool
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
int alloc_mb_stride
mb_stride used to allocate tables
void ff_mpv_common_end(MpegEncContext *s)
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
av_cold void ff_blockdsp_init(BlockDSPContext *c)
int ff_mpv_framesize_alloc(AVCodecContext *avctx, ScratchpadContext *sc, int linesize)
static const uint8_t *const ff_mpeg1_dc_scale_table
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, int16_t *block, int n, int qscale)
#define ALLOC_POOL(name, size, flags)
const uint8_t * scantable
struct FFRefStructPool * motion_val_pool
struct FFRefStructPool * ref_index_pool
struct FFRefStructPool * mbskip_table_pool
int alloc_mb_height
mb_height used to allocate tables
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
void ff_mpv_unref_picture(MPVWorkPicture *pic)
av_cold void ff_mpv_idct_init(MpegEncContext *s)
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
const uint8_t ff_alternate_horizontal_scan[64]
static void free_buffer_pools(BufferPoolContext *pools)
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
int ff_mpeg_er_init(MpegEncContext *s)
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
static void clear_context(MpegEncContext *s)
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
#define FF_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
If this flag is set, the entries will be zeroed before being returned to the user (after the init or ...
struct FFRefStructPool * qscale_table_pool
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
static void dct_unquantize_h263_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
#define i(width, name, range_min, range_max)
const uint8_t ff_alternate_vertical_scan[64]
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
void ff_mpv_common_init_ppc(MpegEncContext *s)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_calloc(size_t nmemb, size_t size)
const uint8_t ff_zigzag_direct[64]
static av_cold int dct_init(MpegEncContext *s)
void ff_mpv_free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution as well as the slice thread contex...
static void dct_unquantize_h263_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
const uint8_t ff_default_chroma_qscale_table[32]
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
Initialize an MpegEncContext's thread contexts.
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
The exact code depends on how similar the blocks are and how related they are to the block
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...
int alloc_mb_width
mb_width used to allocate tables
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)