comp               80 compat/cuda/cuda_runtime.h #define GETCOMP(reg, comp) \
comp               81 compat/cuda/cuda_runtime.h     asm("mov.u32 %0, %%" #reg "." #comp ";" : "=r"(tmp)); \
comp               82 compat/cuda/cuda_runtime.h     ret.comp = tmp;
comp             3360 fftools/ffmpeg.c                                                  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
comp             3170 fftools/ffprobe.c                 print_int("bit_depth", pixdesc->comp[i].depth);
comp               40 libavcodec/bmp.c     BiCompression comp;
comp              117 libavcodec/bmp.c         comp = bytestream_get_le32(&buf);
comp              119 libavcodec/bmp.c         comp = BMP_RGB;
comp              121 libavcodec/bmp.c     if (comp != BMP_RGB && comp != BMP_BITFIELDS && comp != BMP_RLE4 &&
comp              122 libavcodec/bmp.c         comp != BMP_RLE8) {
comp              123 libavcodec/bmp.c         av_log(avctx, AV_LOG_ERROR, "BMP coding %d not supported\n", comp);
comp              127 libavcodec/bmp.c     if (comp == BMP_BITFIELDS) {
comp              146 libavcodec/bmp.c         if (comp == BMP_BITFIELDS) {
comp              168 libavcodec/bmp.c         if (comp == BMP_RGB)
comp              170 libavcodec/bmp.c         else if (comp == BMP_BITFIELDS) {
comp              222 libavcodec/bmp.c     if (n * avctx->height > dsize && comp != BMP_RLE4 && comp != BMP_RLE8) {
comp              233 libavcodec/bmp.c     if (comp == BMP_RLE4 || comp == BMP_RLE8)
comp              278 libavcodec/bmp.c     if (comp == BMP_RLE4 || comp == BMP_RLE8) {
comp              279 libavcodec/bmp.c         if (comp == BMP_RLE8 && height < 0) {
comp              720 libavcodec/cbs_h265_syntax_template.c     int err, comp, i;
comp              732 libavcodec/cbs_h265_syntax_template.c             for (comp = 0; comp < (current->chroma_format_idc ? 3 : 1); comp++) {
comp              733 libavcodec/cbs_h265_syntax_template.c                 int bit_depth = comp == 0 ? current->bit_depth_luma_minus8 + 8
comp              736 libavcodec/cbs_h265_syntax_template.c                     ubs(bit_depth, sps_palette_predictor_initializers[comp][i], 2, comp, i);
comp              996 libavcodec/cbs_h265_syntax_template.c     int err, comp, i;
comp             1021 libavcodec/cbs_h265_syntax_template.c             for (comp = 0; comp < (current->monochrome_palette_flag ? 1 : 3); comp++) {
comp             1022 libavcodec/cbs_h265_syntax_template.c                 int bit_depth = comp == 0 ? current->luma_bit_depth_entry_minus8 + 8
comp             1025 libavcodec/cbs_h265_syntax_template.c                     ubs(bit_depth, pps_palette_predictor_initializers[comp][i], 2, comp, i);
comp              462 libavcodec/clearvideo.c     int comp, i, j;
comp              464 libavcodec/clearvideo.c     for (comp = 0; comp < 3; comp++) {
comp              465 libavcodec/clearvideo.c         int shift = comp > 0;
comp              468 libavcodec/clearvideo.c         int size = comp == 0 ? tile_size : tile_size >> 1;
comp              469 libavcodec/clearvideo.c         int stride = buf->linesize[comp];
comp              470 libavcodec/clearvideo.c         uint8_t *framebuf = buf->data[comp];
comp              808 libavcodec/cuviddec.c         probed_bit_depth = probe_desc->comp[0].depth;
comp              656 libavcodec/diracdec.c static int decode_component(DiracContext *s, int comp)
comp              669 libavcodec/diracdec.c             SubBand *b = &s->plane[comp].band[level][orientation];
comp              693 libavcodec/diracdec.c             avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
comp             1872 libavcodec/diracdec.c     int y, i, comp, dsty;
comp             1878 libavcodec/diracdec.c             for (comp = 0; comp < 3; comp++) {
comp             1879 libavcodec/diracdec.c                 Plane *p = &s->plane[comp];
comp             1889 libavcodec/diracdec.c     for (comp = 0; comp < 3; comp++) {
comp             1890 libavcodec/diracdec.c         Plane *p       = &s->plane[comp];
comp             1891 libavcodec/diracdec.c         uint8_t *frame = s->current_picture->avframe->data[comp];
comp             1900 libavcodec/diracdec.c             ret = decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
comp             1924 libavcodec/diracdec.c                 int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
comp             1948 libavcodec/diracdec.c                 mc_row(s, blocks, mctmp, comp, dsty);
comp               42 libavcodec/dpxenc.c     s->bits_per_component = desc->comp[0].depth;
comp               73 libavcodec/dxva2_vp9.c     pp->BitDepthMinus8Luma   = pixdesc->comp[0].depth - 8;
comp               74 libavcodec/dxva2_vp9.c     pp->BitDepthMinus8Chroma = pixdesc->comp[1].depth - 8;
comp              100 libavcodec/eamad.c         comp(frame->data[0] + (mb_y*16 + ((j&2)<<2))*frame->linesize[0] + mb_x*16 + ((j&1)<<3),
comp              109 libavcodec/eamad.c         comp(frame->data[index] + (mb_y*8)*frame->linesize[index] + mb_x * 8,
comp             1146 libavcodec/exr.c             int plane = s->desc->comp[c].plane;
comp              248 libavcodec/ffv1dec.c     const int ps      = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
comp              944 libavcodec/ffv1dec.c                 int pixshift = desc->comp[j].depth > 8;
comp             1051 libavcodec/ffv1enc.c     const int ps     = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
comp              102 libavcodec/flashsv2enc.c     int use15_7, dist, comp;
comp              183 libavcodec/flashsv2enc.c     s->comp = avctx->compression_level;
comp              184 libavcodec/flashsv2enc.c     if (s->comp == -1)
comp              185 libavcodec/flashsv2enc.c         s->comp = 9;
comp              186 libavcodec/flashsv2enc.c     if (s->comp < 0 || s->comp > 9) {
comp              188 libavcodec/flashsv2enc.c                "Compression level should be 0-9, not %d\n", s->comp);
comp              352 libavcodec/flashsv2enc.c static int encode_zlib(Block * b, uint8_t * buf, unsigned long *buf_size, int comp)
comp              354 libavcodec/flashsv2enc.c     int res = compress2(buf, buf_size, b->sl_begin, b->sl_end - b->sl_begin, comp);
comp              359 libavcodec/flashsv2enc.c                             int *buf_size, int comp)
comp              366 libavcodec/flashsv2enc.c     res = deflateInit(&s, comp);
comp              554 libavcodec/flashsv2enc.c                         Block * prev, const uint8_t * src, int stride, int comp,
comp              569 libavcodec/flashsv2enc.c         res = encode_zlib(b, b->data, &b->data_size, comp);
comp              574 libavcodec/flashsv2enc.c             res = encode_zlibprime(b, prev, buf, &buf_size, comp);
comp              651 libavcodec/flashsv2enc.c             res = encode_block(s, &s->palette, b, prev, data, s->image_width * 3, s->comp, s->dist, keyframe);
comp             3121 libavcodec/hevcdec.c     pixel_shift = desc->comp[0].depth > 8;
comp              238 libavcodec/huffyuvenc.c     s->bps = desc->comp[0].depth;
comp               98 libavcodec/imgconvert.c         planes[desc->comp[i].plane] = 1;
comp              102 libavcodec/j2kenc.c    Jpeg2000Component *comp;
comp              145 libavcodec/j2kenc.c static void printcomp(Jpeg2000Component *comp)
comp              148 libavcodec/j2kenc.c     for (i = 0; i < comp->y1 - comp->y0; i++)
comp              149 libavcodec/j2kenc.c         ff_jpeg2000_printv(comp->i_data + i * (comp->x1 - comp->x0), comp->x1 - comp->x0);
comp              165 libavcodec/j2kenc.c             Jpeg2000Component *comp = tile->comp + compno;
comp              170 libavcodec/j2kenc.c                         comp->x0, comp->x1, comp->y0, comp->y1);
comp              172 libavcodec/j2kenc.c                 Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
comp              420 libavcodec/j2kenc.c             tile->comp = av_mallocz_array(s->ncomponents, sizeof(Jpeg2000Component));
comp              421 libavcodec/j2kenc.c             if (!tile->comp)
comp              424 libavcodec/j2kenc.c                 Jpeg2000Component *comp = tile->comp + compno;
comp              427 libavcodec/j2kenc.c                 comp->coord[0][0] = comp->coord_o[0][0] = tilex * s->tile_width;
comp              428 libavcodec/j2kenc.c                 comp->coord[0][1] = comp->coord_o[0][1] = FFMIN((tilex+1)*s->tile_width, s->width);
comp              429 libavcodec/j2kenc.c                 comp->coord[1][0] = comp->coord_o[1][0] = tiley * s->tile_height;
comp              430 libavcodec/j2kenc.c                 comp->coord[1][1] = comp->coord_o[1][1] = FFMIN((tiley+1)*s->tile_height, s->height);
comp              434 libavcodec/j2kenc.c                             comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]);
comp              436 libavcodec/j2kenc.c                 if ((ret = ff_jpeg2000_init_component(comp,
comp              458 libavcodec/j2kenc.c                 Jpeg2000Component *comp = tile->comp + compno;
comp              459 libavcodec/j2kenc.c                 int *dst = comp->i_data;
comp              461 libavcodec/j2kenc.c                        + comp->coord[1][0] * s->picture->linesize[compno]
comp              462 libavcodec/j2kenc.c                        + comp->coord[0][0];
comp              463 libavcodec/j2kenc.c                 for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){
comp              465 libavcodec/j2kenc.c                     for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++)
comp              471 libavcodec/j2kenc.c             line = s->picture->data[0] + tile->comp[0].coord[1][0] * s->picture->linesize[0]
comp              472 libavcodec/j2kenc.c                    + tile->comp[0].coord[0][0] * s->ncomponents;
comp              475 libavcodec/j2kenc.c             for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){
comp              477 libavcodec/j2kenc.c                 for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){
comp              479 libavcodec/j2kenc.c                         tile->comp[compno].i_data[i] = *ptr++  - (1 << 7);
comp              824 libavcodec/j2kenc.c             Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
comp              860 libavcodec/j2kenc.c         Jpeg2000Component *comp = tile->comp + compno;
comp              863 libavcodec/j2kenc.c             Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
comp              889 libavcodec/j2kenc.c         Jpeg2000Component *comp = s->tile[tileno].comp + compno;
comp              894 libavcodec/j2kenc.c         if ((ret = ff_dwt_encode(&comp->dwt, comp->i_data)) < 0)
comp              899 libavcodec/j2kenc.c             Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
comp              905 libavcodec/j2kenc.c                 yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
comp              919 libavcodec/j2kenc.c                         xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];
comp              930 libavcodec/j2kenc.c                                     *ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] * (1 << NMSEDEC_FRACBITS);
comp              937 libavcodec/j2kenc.c                                     *ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
comp              977 libavcodec/j2kenc.c             Jpeg2000Component *comp = s->tile[tileno].comp + compno;
comp              978 libavcodec/j2kenc.c             ff_jpeg2000_cleanup(comp, codsty);
comp              980 libavcodec/j2kenc.c         av_freep(&s->tile[tileno].comp);
comp              991 libavcodec/j2kenc.c             ff_jpeg2000_reinit(tile->comp + compno, &s->codsty);
comp              265 libavcodec/jpeg2000.c                      Jpeg2000Component *comp,
comp              353 libavcodec/jpeg2000.c             cblk->coord[0][0] += comp->reslevel[reslevelno-1].coord[0][1] -
comp              354 libavcodec/jpeg2000.c                                  comp->reslevel[reslevelno-1].coord[0][0];
comp              355 libavcodec/jpeg2000.c             cblk->coord[0][1] += comp->reslevel[reslevelno-1].coord[0][1] -
comp              356 libavcodec/jpeg2000.c                                  comp->reslevel[reslevelno-1].coord[0][0];
comp              359 libavcodec/jpeg2000.c             cblk->coord[1][0] += comp->reslevel[reslevelno-1].coord[1][1] -
comp              360 libavcodec/jpeg2000.c                                  comp->reslevel[reslevelno-1].coord[1][0];
comp              361 libavcodec/jpeg2000.c             cblk->coord[1][1] += comp->reslevel[reslevelno-1].coord[1][1] -
comp              362 libavcodec/jpeg2000.c                                  comp->reslevel[reslevelno-1].coord[1][0];
comp              375 libavcodec/jpeg2000.c                      Jpeg2000Component *comp,
comp              399 libavcodec/jpeg2000.c                     ff_jpeg2000_ceildivpow2(comp->coord_o[i][j],
comp              415 libavcodec/jpeg2000.c                     ff_jpeg2000_ceildivpow2(comp->coord_o[i][j] -
comp              441 libavcodec/jpeg2000.c         ret = init_prec(band, reslevel, comp,
comp              451 libavcodec/jpeg2000.c int ff_jpeg2000_init_component(Jpeg2000Component *comp,
comp              465 libavcodec/jpeg2000.c     if (ret = ff_jpeg2000_dwt_init(&comp->dwt, comp->coord,
comp              470 libavcodec/jpeg2000.c     if (av_image_check_size(comp->coord[0][1] - comp->coord[0][0],
comp              471 libavcodec/jpeg2000.c                             comp->coord[1][1] - comp->coord[1][0], 0, avctx))
comp              473 libavcodec/jpeg2000.c     csize = (comp->coord[0][1] - comp->coord[0][0]) *
comp              474 libavcodec/jpeg2000.c             (comp->coord[1][1] - comp->coord[1][0]);
comp              475 libavcodec/jpeg2000.c     if (comp->coord[0][1] - comp->coord[0][0] > 32768 ||
comp              476 libavcodec/jpeg2000.c         comp->coord[1][1] - comp->coord[1][0] > 32768) {
comp              482 libavcodec/jpeg2000.c         csize += AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*comp->f_data);
comp              483 libavcodec/jpeg2000.c         comp->i_data = NULL;
comp              484 libavcodec/jpeg2000.c         comp->f_data = av_mallocz_array(csize, sizeof(*comp->f_data));
comp              485 libavcodec/jpeg2000.c         if (!comp->f_data)
comp              488 libavcodec/jpeg2000.c         csize += AV_INPUT_BUFFER_PADDING_SIZE / sizeof(*comp->i_data);
comp              489 libavcodec/jpeg2000.c         comp->f_data = NULL;
comp              490 libavcodec/jpeg2000.c         comp->i_data = av_mallocz_array(csize, sizeof(*comp->i_data));
comp              491 libavcodec/jpeg2000.c         if (!comp->i_data)
comp              494 libavcodec/jpeg2000.c     comp->reslevel = av_mallocz_array(codsty->nreslevels, sizeof(*comp->reslevel));
comp              495 libavcodec/jpeg2000.c     if (!comp->reslevel)
comp              500 libavcodec/jpeg2000.c         Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
comp              508 libavcodec/jpeg2000.c                     ff_jpeg2000_ceildivpow2(comp->coord_o[i][j], declvl - 1);
comp              554 libavcodec/jpeg2000.c                             comp, codsty, qntsty,
comp              564 libavcodec/jpeg2000.c void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
comp              568 libavcodec/jpeg2000.c         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp              585 libavcodec/jpeg2000.c void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
comp              589 libavcodec/jpeg2000.c          comp->reslevel && reslevelno < codsty->nreslevels;
comp              593 libavcodec/jpeg2000.c         if (!comp->reslevel)
comp              596 libavcodec/jpeg2000.c         reslevel = comp->reslevel + reslevelno;
comp              630 libavcodec/jpeg2000.c     ff_dwt_destroy(&comp->dwt);
comp              631 libavcodec/jpeg2000.c     av_freep(&comp->reslevel);
comp              632 libavcodec/jpeg2000.c     av_freep(&comp->i_data);
comp              633 libavcodec/jpeg2000.c     av_freep(&comp->f_data);
comp              265 libavcodec/jpeg2000.h int ff_jpeg2000_init_component(Jpeg2000Component *comp,
comp              271 libavcodec/jpeg2000.h void ff_jpeg2000_reinit(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
comp              273 libavcodec/jpeg2000.h void ff_jpeg2000_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty);
comp               80 libavcodec/jpeg2000dec.c     Jpeg2000Component   *comp;
comp              214 libavcodec/jpeg2000dec.c         match = match && desc->comp[3].depth >= bpc &&
comp              218 libavcodec/jpeg2000dec.c         match = match && desc->comp[2].depth >= bpc &&
comp              222 libavcodec/jpeg2000dec.c         match = match && desc->comp[1].depth >= bpc &&
comp              227 libavcodec/jpeg2000dec.c         match = match && desc->comp[0].depth >= bpc &&
comp              368 libavcodec/jpeg2000dec.c         tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
comp              369 libavcodec/jpeg2000dec.c         if (!tile->comp)
comp              627 libavcodec/jpeg2000dec.c             s->tile[s->curtileno].comp[compno].roi_shift = v;
comp              954 libavcodec/jpeg2000dec.c     if (!tile->comp)
comp              963 libavcodec/jpeg2000dec.c         Jpeg2000Component *comp = tile->comp + compno;
comp              968 libavcodec/jpeg2000dec.c         comp->coord_o[0][0] = tile->coord[0][0];
comp              969 libavcodec/jpeg2000dec.c         comp->coord_o[0][1] = tile->coord[0][1];
comp              970 libavcodec/jpeg2000dec.c         comp->coord_o[1][0] = tile->coord[1][0];
comp              971 libavcodec/jpeg2000dec.c         comp->coord_o[1][1] = tile->coord[1][1];
comp              973 libavcodec/jpeg2000dec.c             comp->coord_o[0][0] /= s->cdx[compno];
comp              974 libavcodec/jpeg2000dec.c             comp->coord_o[0][1] /= s->cdx[compno];
comp              975 libavcodec/jpeg2000dec.c             comp->coord_o[1][0] /= s->cdy[compno];
comp              976 libavcodec/jpeg2000dec.c             comp->coord_o[1][1] /= s->cdy[compno];
comp              979 libavcodec/jpeg2000dec.c         comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
comp              980 libavcodec/jpeg2000dec.c         comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
comp              981 libavcodec/jpeg2000dec.c         comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
comp              982 libavcodec/jpeg2000dec.c         comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
comp              984 libavcodec/jpeg2000dec.c         if (!comp->roi_shift)
comp              985 libavcodec/jpeg2000dec.c             comp->roi_shift = s->roi_shift[compno];
comp              987 libavcodec/jpeg2000dec.c         if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
comp             1239 libavcodec/jpeg2000dec.c                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
comp             1265 libavcodec/jpeg2000dec.c                         Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
comp             1284 libavcodec/jpeg2000dec.c             Jpeg2000Component *comp     = tile->comp + compno;
comp             1295 libavcodec/jpeg2000dec.c                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1311 libavcodec/jpeg2000dec.c                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1324 libavcodec/jpeg2000dec.c                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
comp             1325 libavcodec/jpeg2000dec.c                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
comp             1356 libavcodec/jpeg2000dec.c                 Jpeg2000Component *comp     = tile->comp + compno;
comp             1361 libavcodec/jpeg2000dec.c                     Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1372 libavcodec/jpeg2000dec.c                         Jpeg2000Component *comp     = tile->comp + compno;
comp             1376 libavcodec/jpeg2000dec.c                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1394 libavcodec/jpeg2000dec.c                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
comp             1395 libavcodec/jpeg2000dec.c                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
comp             1425 libavcodec/jpeg2000dec.c             Jpeg2000Component *comp     = tile->comp + compno;
comp             1430 libavcodec/jpeg2000dec.c                 Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1445 libavcodec/jpeg2000dec.c                     Jpeg2000Component *comp     = tile->comp + compno;
comp             1454 libavcodec/jpeg2000dec.c                         Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1465 libavcodec/jpeg2000dec.c                         prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
comp             1466 libavcodec/jpeg2000dec.c                         prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
comp             1731 libavcodec/jpeg2000dec.c static inline int roi_shift_param(Jpeg2000Component *comp,
comp             1736 libavcodec/jpeg2000dec.c     roi_shift = comp->roi_shift;
comp             1752 libavcodec/jpeg2000dec.c                                  Jpeg2000Component *comp,
comp             1758 libavcodec/jpeg2000dec.c         float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
comp             1767 libavcodec/jpeg2000dec.c                                Jpeg2000Component *comp,
comp             1773 libavcodec/jpeg2000dec.c         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
comp             1787 libavcodec/jpeg2000dec.c                                Jpeg2000Component *comp,
comp             1793 libavcodec/jpeg2000dec.c         int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
comp             1810 libavcodec/jpeg2000dec.c         if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
comp             1818 libavcodec/jpeg2000dec.c             src[i] = tile->comp[i].f_data;
comp             1820 libavcodec/jpeg2000dec.c             src[i] = tile->comp[i].i_data;
comp             1823 libavcodec/jpeg2000dec.c         csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
comp             1829 libavcodec/jpeg2000dec.c                                   Jpeg2000Component *comp,
comp             1837 libavcodec/jpeg2000dec.c             src[i] = roi_shift_param(comp, src[i]);
comp             1849 libavcodec/jpeg2000dec.c         Jpeg2000Component *comp     = tile->comp + compno;
comp             1857 libavcodec/jpeg2000dec.c             Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
comp             1884 libavcodec/jpeg2000dec.c                                     bandpos, comp->roi_shift);
comp             1892 libavcodec/jpeg2000dec.c                         if (comp->roi_shift)
comp             1893 libavcodec/jpeg2000dec.c                             roi_scale_cblk(cblk, comp, &t1);
comp             1895 libavcodec/jpeg2000dec.c                             dequantization_float(x, y, cblk, comp, &t1, band);
comp             1897 libavcodec/jpeg2000dec.c                             dequantization_int_97(x, y, cblk, comp, &t1, band);
comp             1899 libavcodec/jpeg2000dec.c                             dequantization_int(x, y, cblk, comp, &t1, band);
comp             1907 libavcodec/jpeg2000dec.c             ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
comp             1924 libavcodec/jpeg2000dec.c             Jpeg2000Component *comp     = tile->comp + compno;                                    \
comp             1927 libavcodec/jpeg2000dec.c             float *datap     = comp->f_data;                                                      \
comp             1928 libavcodec/jpeg2000dec.c             int32_t *i_datap = comp->i_data;                                                      \
comp             1930 libavcodec/jpeg2000dec.c             int w            = tile->comp[compno].coord[0][1] - s->image_offset_x;                \
comp             1936 libavcodec/jpeg2000dec.c             y    = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];           \
comp             1938 libavcodec/jpeg2000dec.c             for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) {                 \
comp             1941 libavcodec/jpeg2000dec.c                 x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
comp             2017 libavcodec/jpeg2000dec.c         if (s->tile[tileno].comp) {
comp             2019 libavcodec/jpeg2000dec.c                 Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
comp             2022 libavcodec/jpeg2000dec.c                 ff_jpeg2000_cleanup(comp, codsty);
comp             2024 libavcodec/jpeg2000dec.c             av_freep(&s->tile[tileno].comp);
comp              227 libavcodec/jpeglsdec.c                                   int stride, int comp, int bits)
comp              257 libavcodec/jpeglsdec.c                 r = 1 << ff_log2_run[state->run_index[comp]];
comp              265 libavcodec/jpeglsdec.c                 if (r != 1 << ff_log2_run[state->run_index[comp]])
comp              267 libavcodec/jpeglsdec.c                 if (state->run_index[comp] < 31)
comp              268 libavcodec/jpeglsdec.c                     state->run_index[comp]++;
comp              273 libavcodec/jpeglsdec.c             r = ff_log2_run[state->run_index[comp]];
comp              294 libavcodec/jpeglsdec.c                                          ff_log2_run[state->run_index[comp]]);
comp              295 libavcodec/jpeglsdec.c             if (state->run_index[comp])
comp              296 libavcodec/jpeglsdec.c                 state->run_index[comp]--;
comp              109 libavcodec/jpeglsenc.c                                  int comp, int trail)
comp              111 libavcodec/jpeglsenc.c     while (run >= (1 << ff_log2_run[state->run_index[comp]])) {
comp              113 libavcodec/jpeglsenc.c         run -= 1 << ff_log2_run[state->run_index[comp]];
comp              114 libavcodec/jpeglsenc.c         if (state->run_index[comp] < 31)
comp              115 libavcodec/jpeglsenc.c             state->run_index[comp]++;
comp              122 libavcodec/jpeglsenc.c         if (ff_log2_run[state->run_index[comp]])
comp              123 libavcodec/jpeglsenc.c             put_bits(pb, ff_log2_run[state->run_index[comp]], run);
comp              132 libavcodec/jpeglsenc.c                                   int stride, int comp, int bits)
comp              163 libavcodec/jpeglsenc.c             ls_encode_run(state, pb, run, comp, x < w);
comp              192 libavcodec/jpeglsenc.c                               ff_log2_run[state->run_index[comp]]);
comp              194 libavcodec/jpeglsenc.c             if (state->run_index[comp] > 0)
comp              195 libavcodec/jpeglsenc.c                 state->run_index[comp]--;
comp              169 libavcodec/libopenjpegdec.c                 desc->comp[3].depth >= image->comps[3].prec &&
comp              174 libavcodec/libopenjpegdec.c                 desc->comp[2].depth >= image->comps[2].prec &&
comp              179 libavcodec/libopenjpegdec.c                 desc->comp[1].depth >= image->comps[1].prec &&
comp              184 libavcodec/libopenjpegdec.c                 desc->comp[0].depth >= image->comps[0].prec &&
comp              234 libavcodec/libopenjpegdec.c     component_plane = desc->comp[0].plane;
comp              236 libavcodec/libopenjpegdec.c         if (component_plane != desc->comp[i].plane)
comp              259 libavcodec/libopenjpegdec.c         adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;
comp              296 libavcodec/libopenjpegdec.c         adjust[x] = FFMAX(FFMIN(desc->comp[x].depth - image->comps[x].prec, 8), 0) + desc->comp[x].shift;
comp              441 libavcodec/libopenjpegdec.c     pixel_size = desc->comp[0].step;
comp              255 libavcodec/libopenjpegenc.c         cmptparm[i].prec = desc->comp[i].depth;
comp              256 libavcodec/libopenjpegenc.c         cmptparm[i].bpp  = desc->comp[i].depth;
comp              381 libavcodec/librav1e.c     rret = rav1e_config_set_pixel_format(cfg, desc->comp[0].depth,
comp              436 libavcodec/librav1e.c             int bytes = desc->comp[0].depth == 8 ? 1 : 2;
comp              621 libavcodec/libx264.c     x4->params.i_bitdepth           = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
comp              123 libavcodec/libx265.c     ctx->api = x265_api_get(av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth);
comp              497 libavcodec/libx265.c         x265pic.bitDepth = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth;
comp              290 libavcodec/mips/me_cmp_msa.c     v16u8 src0, src1, src2, src3, comp, diff;
comp              312 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp1, (v16i8) comp0);
comp              313 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src0, comp);
comp              322 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp3, (v16i8) comp2);
comp              323 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src1, comp);
comp              332 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp1, (v16i8) comp0);
comp              333 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src2, comp);
comp              342 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp3, (v16i8) comp2);
comp              343 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src3, comp);
comp              358 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp1, (v16i8) comp0);
comp              359 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src0, comp);
comp              368 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp3, (v16i8) comp2);
comp              369 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src1, comp);
comp              378 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp1, (v16i8) comp0);
comp              379 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src2, comp);
comp              388 libavcodec/mips/me_cmp_msa.c         comp = (v16u8) __msa_pckev_b((v16i8) comp3, (v16i8) comp2);
comp              389 libavcodec/mips/me_cmp_msa.c         diff = __msa_asub_u_b(src3, comp);
comp             2583 libavcodec/mjpegdec.c     is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
comp              370 libavcodec/nvdec.c     switch (sw_desc->comp[0].depth) {
comp              392 libavcodec/nvdec.c     params.bitDepthMinus8      = sw_desc->comp[0].depth - 8;
comp              687 libavcodec/nvdec.c     switch (sw_desc->comp[0].depth) {
comp               77 libavcodec/nvdec_vp9.c             .bitDepthMinus8Luma       = pixdesc->comp[0].depth - 8,
comp               78 libavcodec/nvdec_vp9.c             .bitDepthMinus8Chroma     = pixdesc->comp[1].depth - 8,
comp               87 libavcodec/pnmenc.c         int maxdepth = (1 << av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].depth) - 1;
comp              538 libavcodec/qdm2.c     int tmp, acc, esp_40, comp;
comp              587 libavcodec/qdm2.c                     comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
comp              588 libavcodec/qdm2.c                     if (comp < 0)
comp              589 libavcodec/qdm2.c                         comp += 0xff;
comp              590 libavcodec/qdm2.c                     comp /= 256; // signed shift
comp              593 libavcodec/qdm2.c                             if (comp < 30)
comp              594 libavcodec/qdm2.c                                 comp = 30;
comp              595 libavcodec/qdm2.c                             comp += 15;
comp              598 libavcodec/qdm2.c                             if (comp < 24)
comp              599 libavcodec/qdm2.c                                 comp = 24;
comp              600 libavcodec/qdm2.c                             comp += 10;
comp              605 libavcodec/qdm2.c                             if (comp < 16)
comp              606 libavcodec/qdm2.c                                 comp = 16;
comp              608 libavcodec/qdm2.c                     if (comp <= 5)
comp              610 libavcodec/qdm2.c                     else if (comp <= 10)
comp              612 libavcodec/qdm2.c                     else if (comp <= 16)
comp              614 libavcodec/qdm2.c                     else if (comp <= 24)
comp              449 libavcodec/qsvenc.c     q->param.mfx.FrameInfo.BitDepthLuma   = desc->comp[0].depth;
comp              450 libavcodec/qsvenc.c     q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
comp              451 libavcodec/qsvenc.c     q->param.mfx.FrameInfo.Shift          = desc->comp[0].depth > 8;
comp              551 libavcodec/qsvenc.c     q->param.mfx.FrameInfo.BitDepthLuma   = desc->comp[0].depth;
comp              552 libavcodec/qsvenc.c     q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
comp              553 libavcodec/qsvenc.c     q->param.mfx.FrameInfo.Shift          = desc->comp[0].depth > 8;
comp               47 libavcodec/scpr.c     int comp, i, j;
comp               49 libavcodec/scpr.c     for (comp = 0; comp < 3; comp++) {
comp               51 libavcodec/scpr.c             if (s->pixel_model[comp][j].total_freq != 256) {
comp               53 libavcodec/scpr.c                     s->pixel_model[comp][j].freq[i] = 1;
comp               55 libavcodec/scpr.c                     s->pixel_model[comp][j].lookup[i] = 16;
comp               56 libavcodec/scpr.c                 s->pixel_model[comp][j].total_freq = 256;
comp               63 libavcodec/smvjpegdec.c         planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
comp              317 libavcodec/tiffenc.c         bpp_tab[i] = desc->comp[i].depth;
comp              424 libavcodec/utils.c         if (desc->comp[0].depth >= 9) {
comp              861 libavcodec/utils.c                 || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
comp              863 libavcodec/utils.c                     avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
comp              864 libavcodec/utils.c                 avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
comp             1271 libavcodec/utils.c                 enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
comp              381 libavcodec/v4l2_buffers.c             planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
comp             1249 libavcodec/vaapi_encode.c     depth = desc->comp[0].depth;
comp             1251 libavcodec/vaapi_encode.c         if (desc->comp[i].depth != depth) {
comp              295 libavcodec/vaapi_encode_h265.c     bit_depth = desc->comp[0].depth;
comp             1027 libavcodec/vc2enc.c     const int depth = fmt->comp[0].depth;
comp               79 libavcodec/vdpau_vp9.c     info->bitDepthMinus8Luma       = pixdesc->comp[0].depth - 8;
comp               80 libavcodec/vdpau_vp9.c     info->bitDepthMinus8Chroma     = pixdesc->comp[1].depth - 8;
comp             1029 libavcodec/videotoolbox.c     int depth = descriptor->comp[0].depth;
comp               91 libavcodec/vp5.c     int comp, di;
comp               93 libavcodec/vp5.c     for (comp=0; comp<2; comp++) {
comp               95 libavcodec/vp5.c         if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
comp               96 libavcodec/vp5.c             int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
comp               97 libavcodec/vp5.c             di  = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
comp               98 libavcodec/vp5.c             di |= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
comp              100 libavcodec/vp5.c                                       model->vector_pdv[comp]);
comp              104 libavcodec/vp5.c         if (!comp)
comp              115 libavcodec/vp5.c     int comp, node;
comp              117 libavcodec/vp5.c     for (comp=0; comp<2; comp++) {
comp              118 libavcodec/vp5.c         if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][0]))
comp              119 libavcodec/vp5.c             model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
comp              120 libavcodec/vp5.c         if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][1]))
comp              121 libavcodec/vp5.c             model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
comp              122 libavcodec/vp5.c         if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][2]))
comp              123 libavcodec/vp5.c             model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
comp              124 libavcodec/vp5.c         if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][3]))
comp              125 libavcodec/vp5.c             model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
comp              128 libavcodec/vp5.c     for (comp=0; comp<2; comp++)
comp              130 libavcodec/vp5.c             if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
comp              131 libavcodec/vp5.c                 model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
comp              233 libavcodec/vp6.c     int comp, node;
comp              235 libavcodec/vp6.c     for (comp=0; comp<2; comp++) {
comp              236 libavcodec/vp6.c         if (vp56_rac_get_prob_branchy(c, vp6_sig_dct_pct[comp][0]))
comp              237 libavcodec/vp6.c             model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
comp              238 libavcodec/vp6.c         if (vp56_rac_get_prob_branchy(c, vp6_sig_dct_pct[comp][1]))
comp              239 libavcodec/vp6.c             model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
comp              242 libavcodec/vp6.c     for (comp=0; comp<2; comp++)
comp              244 libavcodec/vp6.c             if (vp56_rac_get_prob_branchy(c, vp6_pdv_pct[comp][node]))
comp              245 libavcodec/vp6.c                 model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
comp              247 libavcodec/vp6.c     for (comp=0; comp<2; comp++)
comp              249 libavcodec/vp6.c             if (vp56_rac_get_prob_branchy(c, vp6_fdv_pct[comp][node]))
comp              250 libavcodec/vp6.c                 model->vector_fdv[comp][node] = vp56_rac_gets_nn(c, 7);
comp              355 libavcodec/vp6.c     int comp;
comp              361 libavcodec/vp6.c     for (comp=0; comp<2; comp++) {
comp              364 libavcodec/vp6.c         if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
comp              368 libavcodec/vp6.c                 delta |= vp56_rac_get_prob(c, model->vector_fdv[comp][j])<<j;
comp              371 libavcodec/vp6.c                 delta |= vp56_rac_get_prob(c, model->vector_fdv[comp][3])<<3;
comp              376 libavcodec/vp6.c                                       model->vector_pdv[comp]);
comp              379 libavcodec/vp6.c         if (delta && vp56_rac_get_prob_branchy(c, model->vector_sig[comp]))
comp              382 libavcodec/vp6.c         if (!comp)
comp              996 libavcodec/vp9.c                         s->prob.p.comp[i] =
comp              997 libavcodec/vp9.c                             update_prob(&s->c, s->prob.p.comp[i]);
comp               45 libavcodec/vp9_mc_template.c     if (b->comp) {
comp               98 libavcodec/vp9_mc_template.c             if (b->comp) {
comp              172 libavcodec/vp9_mc_template.c             if (b->comp) {
comp              311 libavcodec/vp9_mc_template.c             if (b->comp) {
comp              425 libavcodec/vp9_mc_template.c         if (b->comp) {
comp              220 libavcodec/vp9block.c         b->comp = 0;
comp              271 libavcodec/vp9block.c         b->comp = 0;
comp              334 libavcodec/vp9block.c             b->comp = 0;
comp              339 libavcodec/vp9block.c                 b->comp = s->s.h.comppredmode == PRED_COMPREF;
comp              370 libavcodec/vp9block.c                 b->comp = vp56_rac_get_prob(td->c, s->prob.p.comp[c]);
comp              371 libavcodec/vp9block.c                 td->counts.comp[c][b->comp]++;
comp              377 libavcodec/vp9block.c             if (b->comp) { /* two references */
comp              678 libavcodec/vp9block.c         vref = b->ref[b->comp ? s->s.h.signbias[s->s.h.varcompref[0]] : 0];
comp              726 libavcodec/vp9block.c             SPLAT_CTX(perf->dir##_comp_ctx[off],  b->comp,    n); \
comp              786 libavcodec/vp9block.c         } else if (b->comp) {
comp               54 libavcodec/vp9dec.h     uint8_t comp[5];
comp               82 libavcodec/vp9dec.h     uint8_t seg_id, intra, comp, ref[2], mode[4], uvmode, skip;
comp              181 libavcodec/vp9dec.h         unsigned comp[5][2];
comp              332 libavcodec/vp9mvs.c         if (b->comp) {
comp               91 libavcodec/vp9prob.c             adapt_prob(&p->comp[i], s->td[0].counts.comp[i][0],
comp               92 libavcodec/vp9prob.c                        s->td[0].counts.comp[i][1], 20, 128);
comp              576 libavcodec/vp9recon.c         (b->comp && s->mvscale[b->ref[1]][0] == REF_INVALID_SCALE)) {
comp              585 libavcodec/vp9recon.c     if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
comp               49 libavcodec/x86/huffyuvdsp_init.c     if (EXTERNAL_MMXEXT(cpu_flags) && pix_desc && pix_desc->comp[0].depth<16) {
comp               49 libavcodec/x86/huffyuvencdsp_init.c     if (EXTERNAL_MMXEXT(cpu_flags) && pix_desc && pix_desc->comp[0].depth<16) {
comp               67 libavcodec/zmbv.c     int comp;
comp              434 libavcodec/zmbv.c         c->comp = buf[2];
comp              444 libavcodec/zmbv.c                c->flags,hi_ver,lo_ver,c->comp,c->fmt,c->bw,c->bh);
comp              453 libavcodec/zmbv.c         if (c->comp != 0 && c->comp != 1) {
comp              454 libavcodec/zmbv.c             avpriv_request_sample(avctx, "Compression type %i", c->comp);
comp              530 libavcodec/zmbv.c     if (c->comp == 0) { // uncompressed data
comp              728 libavdevice/opengl_enc.c         shift = (desc->comp[i].depth - 1) >> 3; \
comp              729 libavdevice/opengl_enc.c         opengl->color_map[(i << 2) + (desc->comp[i].offset >> shift)] = 1.0; \
comp             1135 libavdevice/opengl_enc.c     int plane = desc->comp[comp_index].plane;
comp             1162 libavdevice/opengl_enc.c     int plane = desc->comp[comp_index].plane;                                               \
comp               88 libavfilter/boxblur.c #define EVAL_RADIUS_EXPR(comp)                                          \
comp               89 libavfilter/boxblur.c     expr = comp->radius_expr;                                           \
comp               92 libavfilter/boxblur.c     comp->radius = res;                                                 \
comp               95 libavfilter/boxblur.c                "Error when evaluating " #comp " radius expression '%s'\n", expr); \
comp              114 libavfilter/boxblur.c #define CHECK_RADIUS_VAL(w_, h_, comp)                                  \
comp              115 libavfilter/boxblur.c     if (comp->radius < 0 ||                                   \
comp              116 libavfilter/boxblur.c         2*comp->radius > FFMIN(w_, h_)) {                     \
comp              118 libavfilter/boxblur.c                "Invalid " #comp " radius value %d, must be >= 0 and <= %d\n", \
comp              119 libavfilter/boxblur.c                comp->radius, FFMIN(w_, h_)/2);                \
comp              196 libavfilter/drawutils.c         c = &desc->comp[i];
comp              226 libavfilter/drawutils.c         draw->comp_mask[desc->comp[i].plane] |=
comp              227 libavfilter/drawutils.c             1 << desc->comp[i].offset;
comp              242 libavfilter/drawutils.c                 color->comp[0].u8[rgba_map[i]] = rgba[i];
comp              243 libavfilter/drawutils.c                 if (draw->desc->comp[rgba_map[i]].depth > 8) {
comp              244 libavfilter/drawutils.c                     color->comp[0].u16[rgba_map[i]] = color->comp[0].u8[rgba_map[i]] << 8;
comp              249 libavfilter/drawutils.c                 color->comp[rgba_map[i]].u8[0] = rgba[i];
comp              250 libavfilter/drawutils.c                 if (draw->desc->comp[rgba_map[i]].depth > 8)
comp              251 libavfilter/drawutils.c                     color->comp[rgba_map[i]].u16[0] = color->comp[rgba_map[i]].u8[0] << (draw->desc->comp[rgba_map[i]].depth - 8);
comp              257 libavfilter/drawutils.c         color->comp[desc->comp[0].plane].u8[desc->comp[0].offset] = draw->full_range ? RGB_TO_Y_JPEG(rgba[0], rgba[1], rgba[2]) : RGB_TO_Y_CCIR(rgba[0], rgba[1], rgba[2]);
comp              258 libavfilter/drawutils.c         color->comp[desc->comp[1].plane].u8[desc->comp[1].offset] = draw->full_range ? RGB_TO_U_JPEG(rgba[0], rgba[1], rgba[2]) : RGB_TO_U_CCIR(rgba[0], rgba[1], rgba[2], 0);
comp              259 libavfilter/drawutils.c         color->comp[desc->comp[2].plane].u8[desc->comp[2].offset] = draw->full_range ? RGB_TO_V_JPEG(rgba[0], rgba[1], rgba[2]) : RGB_TO_V_CCIR(rgba[0], rgba[1], rgba[2], 0);
comp              260 libavfilter/drawutils.c         color->comp[3].u8[0] = rgba[3];
comp              262 libavfilter/drawutils.c         if (desc->comp[compn].depth > 8) \
comp              263 libavfilter/drawutils.c             color->comp[desc->comp[compn].plane].u16[desc->comp[compn].offset] = \
comp              264 libavfilter/drawutils.c             color->comp[desc->comp[compn].plane].u8[desc->comp[compn].offset] << \
comp              265 libavfilter/drawutils.c                 (draw->desc->comp[compn].depth + draw->desc->comp[compn].shift - 8)
comp              277 libavfilter/drawutils.c         color->comp[0].u8[0] = RGB_TO_Y_CCIR(rgba[0], rgba[1], rgba[2]);
comp              279 libavfilter/drawutils.c         color->comp[1].u8[0] = rgba[3];
comp              334 libavfilter/drawutils.c         if (HAVE_BIGENDIAN && draw->desc->comp[0].depth > 8) {
comp              336 libavfilter/drawutils.c                 color_tmp.comp[plane].u16[x] = av_bswap16(color_tmp.comp[plane].u16[x]);
comp              341 libavfilter/drawutils.c             memcpy(p, color_tmp.comp[plane].u8, draw->pixelstep[plane]);
comp              390 libavfilter/drawutils.c static int component_used(FFDrawContext *draw, int plane, int comp)
comp              392 libavfilter/drawutils.c     return (draw->comp_mask[plane] >> comp) & 1;
comp              450 libavfilter/drawutils.c     unsigned alpha, nb_planes, nb_comp, plane, comp;
comp              459 libavfilter/drawutils.c     if (draw->desc->comp[0].depth <= 8) {
comp              477 libavfilter/drawutils.c         for (comp = 0; comp < nb_comp; comp++) {
comp              478 libavfilter/drawutils.c             const int depth = draw->desc->comp[comp].depth;
comp              480 libavfilter/drawutils.c             if (!component_used(draw, plane, comp))
comp              482 libavfilter/drawutils.c             p = p0 + comp;
comp              485 libavfilter/drawutils.c                     blend_line(p, color->comp[plane].u8[comp], alpha >> 1,
comp              489 libavfilter/drawutils.c                     blend_line16(p, color->comp[plane].u16[comp], alpha >> 1,
comp              497 libavfilter/drawutils.c                     blend_line(p, color->comp[plane].u8[comp], alpha,
comp              504 libavfilter/drawutils.c                     blend_line16(p, color->comp[plane].u16[comp], alpha,
comp              512 libavfilter/drawutils.c                     blend_line(p, color->comp[plane].u8[comp], alpha >> 1,
comp              516 libavfilter/drawutils.c                     blend_line16(p, color->comp[plane].u16[comp], alpha >> 1,
comp              627 libavfilter/drawutils.c     unsigned alpha, nb_planes, nb_comp, plane, comp;
comp              637 libavfilter/drawutils.c     if (draw->desc->comp[0].depth <= 8) {
comp              655 libavfilter/drawutils.c         for (comp = 0; comp < nb_comp; comp++) {
comp              656 libavfilter/drawutils.c             const int depth = draw->desc->comp[comp].depth;
comp              658 libavfilter/drawutils.c             if (!component_used(draw, plane, comp))
comp              660 libavfilter/drawutils.c             p = p0 + comp;
comp              665 libavfilter/drawutils.c                                   color->comp[plane].u8[comp], alpha,
comp              671 libavfilter/drawutils.c                                     color->comp[plane].u16[comp], alpha,
comp              682 libavfilter/drawutils.c                                   color->comp[plane].u8[comp], alpha,
comp              692 libavfilter/drawutils.c                                     color->comp[plane].u16[comp], alpha,
comp              703 libavfilter/drawutils.c                                   color->comp[plane].u8[comp], alpha,
comp              709 libavfilter/drawutils.c                                     color->comp[plane].u16[comp], alpha,
comp               68 libavfilter/drawutils.h     } comp[MAX_PLANES];
comp              216 libavfilter/f_select.c     select->bitdepth = desc->comp[0].depth;
comp              211 libavfilter/qsvvpp.c         frameinfo->BitDepthLuma   = desc->comp[0].depth;
comp              212 libavfilter/qsvvpp.c         frameinfo->BitDepthChroma = desc->comp[0].depth;
comp              213 libavfilter/qsvvpp.c         frameinfo->Shift          = desc->comp[0].depth > 8;
comp              221 libavfilter/vf_amplify.c     s->depth = s->desc->comp[0].depth;
comp              297 libavfilter/vf_atadenoise.c     depth = desc->comp[0].depth;
comp              180 libavfilter/vf_avgblur.c     s->depth = desc->comp[0].depth;
comp              100 libavfilter/vf_bilateral.c     s->depth = desc->comp[0].depth;
comp               89 libavfilter/vf_bitplanenoise.c     s->depth = desc->comp[0].depth;
comp              820 libavfilter/vf_blend.c     s->depth = pix_desc->comp[0].depth;
comp              789 libavfilter/vf_bm3d.c     s->depth = desc->comp[0].depth;
comp               67 libavfilter/vf_boxblur.c             (!(desc->flags & AV_PIX_FMT_FLAG_BE) == !HAVE_BIGENDIAN || desc->comp[0].depth == 8) &&
comp              238 libavfilter/vf_boxblur.c     const int depth = desc->comp[0].depth;
comp              222 libavfilter/vf_bwdif.c     int clip_max = (1 << (yadif->csp->comp[td->plane].depth)) - 1;
comp              223 libavfilter/vf_bwdif.c     int df = (yadif->csp->comp[td->plane].depth + 7) / 8;
comp              353 libavfilter/vf_bwdif.c     if (yadif->csp->comp[0].depth > 8) {
comp              253 libavfilter/vf_cas.c     s->depth = desc->comp[0].depth;
comp              280 libavfilter/vf_chromakey.c     ctx->depth = desc->comp[0].depth;
comp              382 libavfilter/vf_chromashift.c     s->depth = desc->comp[0].depth;
comp              373 libavfilter/vf_colorbalance.c     const int depth = desc->comp[0].depth;
comp              411 libavfilter/vf_colorchannelmixer.c     const int depth = desc->comp[0].depth;
comp              159 libavfilter/vf_colorkey.c         ctx->co[i] = desc->comp[i].offset;
comp              100 libavfilter/vf_colorlevels.c     s->bpp = desc->comp[0].depth >> 3;
comp              454 libavfilter/vf_colorspace.c      supported_depth((d)->comp[0].depth) && \
comp              461 libavfilter/vf_colorspace.c                in_desc ? in_desc->comp[0].depth : -1);
comp              468 libavfilter/vf_colorspace.c                out_desc ? out_desc->comp[0].depth : -1);
comp              639 libavfilter/vf_colorspace.c                              in_desc->comp[0].depth == out_desc->comp[0].depth;
comp              646 libavfilter/vf_colorspace.c                                 s->in_rng, in_desc->comp[0].depth);
comp              657 libavfilter/vf_colorspace.c             bits = 1 << (in_desc->comp[0].depth - 1);
comp              669 libavfilter/vf_colorspace.c             s->yuv2rgb = s->dsp.yuv2rgb[(in_desc->comp[0].depth - 8) >> 1]
comp              679 libavfilter/vf_colorspace.c                                 s->out_rng, out_desc->comp[0].depth);
comp              689 libavfilter/vf_colorspace.c             bits = 1 << (29 - out_desc->comp[0].depth);
comp              698 libavfilter/vf_colorspace.c             s->rgb2yuv = s->dsp.rgb2yuv[(out_desc->comp[0].depth - 8) >> 1]
comp              700 libavfilter/vf_colorspace.c             s->rgb2yuv_fsb = s->dsp.rgb2yuv_fsb[(out_desc->comp[0].depth - 8) >> 1]
comp              706 libavfilter/vf_colorspace.c             int idepth = in_desc->comp[0].depth, odepth = out_desc->comp[0].depth;
comp              793 libavfilter/vf_colorspace.c         if (out->color_trc == AVCOL_TRC_BT2020_10 && desc && desc->comp[0].depth >= 12)
comp              565 libavfilter/vf_convolution.c     s->depth = desc->comp[0].depth;
comp              116 libavfilter/vf_convolve.c     s->depth = desc->comp[0].depth;
comp              147 libavfilter/vf_cropdetect.c         s->limit *= (1 << desc->comp[0].depth) - 1;
comp              660 libavfilter/vf_curves.c     curves->is_16bit = desc->comp[0].depth > 8;
comp              661 libavfilter/vf_curves.c     curves->depth = desc->comp[0].depth;
comp              116 libavfilter/vf_datascope.c                 color->comp[0].u8[i] = value[i];
comp              120 libavfilter/vf_datascope.c             color->comp[p].u8[0] = value[p];
comp              134 libavfilter/vf_datascope.c                 color->comp[0].u16[i] = value[i];
comp              138 libavfilter/vf_datascope.c             color->comp[p].u16[0] = value[p];
comp              149 libavfilter/vf_datascope.c         reverse->comp[p].u8[0] = color->comp[p].u8[0] > 127 ? 0 : 255;
comp              150 libavfilter/vf_datascope.c         reverse->comp[p].u8[1] = color->comp[p].u8[1] > 127 ? 0 : 255;
comp              151 libavfilter/vf_datascope.c         reverse->comp[p].u8[2] = color->comp[p].u8[2] > 127 ? 0 : 255;
comp              161 libavfilter/vf_datascope.c         const unsigned max = (1 << draw->desc->comp[p].depth) - 1;
comp              164 libavfilter/vf_datascope.c         reverse->comp[p].u16[0] = color->comp[p].u16[0] > mid ? 0 : max;
comp              165 libavfilter/vf_datascope.c         reverse->comp[p].u16[1] = color->comp[p].u16[1] > mid ? 0 : max;
comp              166 libavfilter/vf_datascope.c         reverse->comp[p].u16[2] = color->comp[p].u16[2] > mid ? 0 : max;
comp              370 libavfilter/vf_datascope.c     s->chars = (s->draw.desc->comp[0].depth + 7) / 8 * 2 + s->dformat;
comp              379 libavfilter/vf_datascope.c     if (s->draw.desc->comp[0].depth <= 8) {
comp              507 libavfilter/vf_datascope.c     if (s->draw.desc->comp[0].depth <= 8) {
comp              792 libavfilter/vf_datascope.c                 if (draw->desc->comp[p].depth == 8) {
comp              795 libavfilter/vf_datascope.c                             out->data[0][y0 * out->linesize[0] + x0 * draw->pixelstep[0] + i] = color->comp[0].u8[i];
comp              798 libavfilter/vf_datascope.c                         out->data[p][out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p])] = color->comp[p].u8[0];
comp              803 libavfilter/vf_datascope.c                             AV_WN16(out->data[0] + y0 * out->linesize[0] + 2 * (x0 * draw->pixelstep[0] + i), color->comp[0].u16[i]);
comp              806 libavfilter/vf_datascope.c                         AV_WN16(out->data[p] + out->linesize[p] * (y0 >> draw->vsub[p]) + (x0 >> draw->hsub[p]) * 2, color->comp[p].u16[0]);
comp              924 libavfilter/vf_datascope.c     if (s->draw.desc->comp[0].depth <= 8) {
comp              932 libavfilter/vf_datascope.c     s->max = (1 << s->draw.desc->comp[0].depth);
comp              964 libavfilter/vf_datascope.c                 if (s->draw.desc->comp[0].depth == 8) {
comp              148 libavfilter/vf_dblur.c     s->depth = desc->comp[0].depth;
comp              383 libavfilter/vf_deband.c         s->deband = desc->comp[0].depth > 8 ? deband_16_coupling_c : deband_8_coupling_c;
comp              385 libavfilter/vf_deband.c         s->deband = desc->comp[0].depth > 8 ? deband_16_c : deband_8_c;
comp              387 libavfilter/vf_deband.c     s->thr[0] = ((1 << desc->comp[0].depth) - 1) * s->threshold[0];
comp              388 libavfilter/vf_deband.c     s->thr[1] = ((1 << desc->comp[1].depth) - 1) * s->threshold[1];
comp              389 libavfilter/vf_deband.c     s->thr[2] = ((1 << desc->comp[2].depth) - 1) * s->threshold[2];
comp              390 libavfilter/vf_deband.c     s->thr[3] = ((1 << desc->comp[3].depth) - 1) * s->threshold[3];
comp              277 libavfilter/vf_deblock.c     s->depth = s->desc->comp[0].depth;
comp              250 libavfilter/vf_decimate.c     dm->depth     = pix_desc->comp[0].depth;
comp              237 libavfilter/vf_dedot.c     s->depth = s->desc->comp[0].depth;
comp              334 libavfilter/vf_deflicker.c     s->depth = desc->comp[0].depth;
comp              114 libavfilter/vf_despill.c         s->co[i] = desc->comp[i].offset;
comp               95 libavfilter/vf_entropy.c     s->depth = desc->comp[0].depth;
comp              153 libavfilter/vf_extractplanes.c     depth = desc->comp[0].depth;
comp              166 libavfilter/vf_extractplanes.c         if (depth != desc->comp[0].depth ||
comp              220 libavfilter/vf_extractplanes.c     s->depth = desc->comp[0].depth >> 3;
comp              252 libavfilter/vf_extractplanes.c                                 int depth, int step, int comp)
comp              260 libavfilter/vf_extractplanes.c                 dst[x] = src[x * step + comp];
comp              264 libavfilter/vf_extractplanes.c                 dst[x * 2    ] = src[x * step + comp * 2    ];
comp              265 libavfilter/vf_extractplanes.c                 dst[x * 2 + 1] = src[x * step + comp * 2 + 1];
comp              416 libavfilter/vf_fade.c     s->depth = pixdesc->comp[0].depth;
comp              195 libavfilter/vf_fftdnoiz.c     s->depth = desc->comp[0].depth;
comp              272 libavfilter/vf_fftfilt.c     s->depth = desc->comp[0].depth;
comp             1036 libavfilter/vf_fieldmatch.c     fm->bpc = (desc->comp[0].depth + 7) / 8;
comp              288 libavfilter/vf_fillborders.c     s->depth = desc->comp[0].depth;
comp              246 libavfilter/vf_floodfill.c     depth = desc->comp[0].depth;
comp              289 libavfilter/vf_framerate.c     s->bitdepth = pix_desc->comp[0].depth;
comp              106 libavfilter/vf_freezedetect.c     s->bitdepth = pix_desc->comp[0].depth;
comp              235 libavfilter/vf_gblur.c     s->depth = desc->comp[0].depth;
comp              358 libavfilter/vf_geq.c     geq->bps = desc->comp[0].depth;
comp               56 libavfilter/vf_hflip.c                desc->comp[0].plane == desc->comp[1].plane)) &&
comp              169 libavfilter/vf_histogram.c     bits = desc->comp[0].depth;
comp              173 libavfilter/vf_histogram.c             (bits != desc->comp[0].depth))
comp              212 libavfilter/vf_histogram.c     s->histogram_size = 1 << s->desc->comp[0].depth;
comp              304 libavfilter/vf_histogram.c                     memset(out->data[s->odesc->comp[k].plane] +
comp              305 libavfilter/vf_histogram.c                            i * out->linesize[s->odesc->comp[k].plane],
comp              312 libavfilter/vf_histogram.c                         AV_WN16(out->data[s->odesc->comp[k].plane] +
comp              313 libavfilter/vf_histogram.c                             i * out->linesize[s->odesc->comp[k].plane] + j * 2,
comp              320 libavfilter/vf_histogram.c         const int p = s->desc->comp[k].plane;
comp              272 libavfilter/vf_hqdn3d.c     s->depth = depth = desc->comp[0].depth;
comp              378 libavfilter/vf_hue.c     const int bps = desc->comp[0].depth > 8 ? 2 : 1;
comp              271 libavfilter/vf_hysteresis.c     s->depth = desc->comp[0].depth;
comp              273 libavfilter/vf_hysteresis.c     if (desc->comp[0].depth == 8)
comp              278 libavfilter/vf_idet.c     if (idet->csp->comp[0].depth > 8){
comp              153 libavfilter/vf_il.c     int comp;
comp              167 libavfilter/vf_il.c     for (comp = 1; comp < (s->nb_planes - s->has_alpha); comp++) {
comp              168 libavfilter/vf_il.c         interleave(out->data[comp], inpicref->data[comp],
comp              169 libavfilter/vf_il.c                    s->linesize[comp], s->chroma_height,
comp              170 libavfilter/vf_il.c                    out->linesize[comp], inpicref->linesize[comp],
comp              175 libavfilter/vf_il.c         comp = s->nb_planes - 1;
comp              176 libavfilter/vf_il.c         interleave(out->data[comp], inpicref->data[comp],
comp              177 libavfilter/vf_il.c                    s->linesize[comp], inlink->h,
comp              178 libavfilter/vf_il.c                    out->linesize[comp], inpicref->linesize[comp],
comp              163 libavfilter/vf_lagfun.c     s->depth = s->desc->comp[0].depth;
comp              164 libavfilter/vf_libvmaf.c     if (s->desc->comp[0].depth <= 8) {
comp              148 libavfilter/vf_limiter.c     depth = desc->comp[0].depth;
comp              166 libavfilter/vf_limiter.c         ff_limiter_init_x86(&s->dsp, desc->comp[0].depth);
comp              115 libavfilter/vf_lumakey.c     depth = desc->comp[0].depth;
comp              228 libavfilter/vf_lut.c     s->is_16bit = desc->comp[0].depth > 8;
comp              266 libavfilter/vf_lut.c         min[Y] = 16 * (1 << (desc->comp[0].depth - 8));
comp              267 libavfilter/vf_lut.c         min[U] = 16 * (1 << (desc->comp[1].depth - 8));
comp              268 libavfilter/vf_lut.c         min[V] = 16 * (1 << (desc->comp[2].depth - 8));
comp              270 libavfilter/vf_lut.c         max[Y] = 235 * (1 << (desc->comp[0].depth - 8));
comp              271 libavfilter/vf_lut.c         max[U] = 240 * (1 << (desc->comp[1].depth - 8));
comp              272 libavfilter/vf_lut.c         max[V] = 240 * (1 << (desc->comp[2].depth - 8));
comp              273 libavfilter/vf_lut.c         max[A] = (1 << desc->comp[0].depth) - 1;
comp              282 libavfilter/vf_lut.c         max[0] = max[1] = max[2] = max[3] = 255 * (1 << (desc->comp[0].depth - 8));
comp              300 libavfilter/vf_lut.c         int comp = s->is_rgb ? rgba_map[color] : color;
comp              310 libavfilter/vf_lut.c                    s->comp_expr_str[comp], comp, color);
comp              318 libavfilter/vf_lut.c         for (val = 0; val < FF_ARRAY_ELEMS(s->lut[comp]); val++) {
comp              329 libavfilter/vf_lut.c                        s->comp_expr_str[color], val, comp);
comp              332 libavfilter/vf_lut.c             s->lut[comp][val] = av_clip((int)res, 0, max[A]);
comp              333 libavfilter/vf_lut.c             av_log(ctx, AV_LOG_DEBUG, "val[%d][%d] = %d\n", comp, val, s->lut[comp][val]);
comp              214 libavfilter/vf_lut2.c     s->depthx = desc->comp[0].depth;
comp              218 libavfilter/vf_lut2.c         s->depthy = desc->comp[0].depth;
comp              234 libavfilter/vf_lut2.c     s->depthy = desc->comp[0].depth;
comp             1065 libavfilter/vf_lut3d.c     depth = desc->comp[0].depth;
comp             1066 libavfilter/vf_lut3d.c     is16bit = desc->comp[0].depth > 8;
comp             1391 libavfilter/vf_lut3d.c     lut3d->clut_bits = desc->comp[0].depth;
comp             1999 libavfilter/vf_lut3d.c     depth = desc->comp[0].depth;
comp             2000 libavfilter/vf_lut3d.c     is16bit = desc->comp[0].depth > 8;
comp              208 libavfilter/vf_maskedclamp.c     s->depth = desc->comp[0].depth;
comp              207 libavfilter/vf_maskedmerge.c     s->depth = desc->comp[0].depth;
comp              210 libavfilter/vf_maskedmerge.c     if (desc->comp[0].depth == 8)
comp              146 libavfilter/vf_maskedminmax.c     s->depth = desc->comp[0].depth;
comp              148 libavfilter/vf_maskedminmax.c     if (desc->comp[0].depth == 8)
comp              120 libavfilter/vf_maskedthreshold.c     s->depth = desc->comp[0].depth;
comp              122 libavfilter/vf_maskedthreshold.c     if (desc->comp[0].depth == 8)
comp              204 libavfilter/vf_maskfun.c     s->depth = desc->comp[0].depth;
comp              139 libavfilter/vf_median.c     s->depth = desc->comp[0].depth;
comp              117 libavfilter/vf_mergeplanes.c         if (desc->comp[0].depth == s->outdesc->comp[0].depth &&
comp              118 libavfilter/vf_mergeplanes.c             (desc->comp[0].depth <= 8 || (desc->flags & AV_PIX_FMT_FLAG_BE) == (s->outdesc->flags & AV_PIX_FMT_FLAG_BE)) &&
comp              189 libavfilter/vf_mergeplanes.c     s->planewidth[2]  = AV_CEIL_RSHIFT(((s->outdesc->comp[1].depth > 8) + 1) * outlink->w, s->outdesc->log2_chroma_w);
comp              191 libavfilter/vf_mergeplanes.c     s->planewidth[3]  = ((s->outdesc->comp[0].depth > 8) + 1) * outlink->w;
comp              217 libavfilter/vf_mergeplanes.c         inputp->planewidth[2]  = AV_CEIL_RSHIFT(((indesc->comp[1].depth > 8) + 1) * inlink->w, indesc->log2_chroma_w);
comp              219 libavfilter/vf_mergeplanes.c         inputp->planewidth[3]  = ((indesc->comp[0].depth > 8) + 1) * inlink->w;
comp              227 libavfilter/vf_mergeplanes.c             inputp->depth[j] = indesc->comp[j].depth;
comp              245 libavfilter/vf_mergeplanes.c         if (s->outdesc->comp[i].depth != inputp->depth[plane]) {
comp              248 libavfilter/vf_mergeplanes.c                                       i, s->outdesc->comp[i].depth,
comp              262 libavfilter/vf_midequalizer.c     s->histogram_size = 1 << desc->comp[0].depth;
comp              347 libavfilter/vf_minterpolate.c     mi_ctx->bitdepth = desc->comp[0].depth;
comp              244 libavfilter/vf_mix.c     s->depth = s->desc->comp[0].depth;
comp              237 libavfilter/vf_neighbor.c     s->depth = desc->comp[0].depth;
comp               70 libavfilter/vf_noise.c static av_cold int init_noise(NoiseContext *n, int comp)
comp               73 libavfilter/vf_noise.c     FilterParams *fp = &n->param[comp];
comp               74 libavfilter/vf_noise.c     AVLFG *lfg = &n->param[comp].lfg;
comp               82 libavfilter/vf_noise.c     av_lfg_init(&fp->lfg, fp->seed + comp*31415U);
comp              140 libavfilter/vf_noise.c         if (desc->flags & AV_PIX_FMT_FLAG_PLANAR && !(desc->comp[0].depth & 7)
comp              192 libavfilter/vf_noise.c                   int width, int start, int end, NoiseContext *n, int comp)
comp              194 libavfilter/vf_noise.c     FilterParams *p = &n->param[comp];
comp              249 libavfilter/vf_noise.c     int comp, i;
comp              262 libavfilter/vf_noise.c     for (comp = 0; comp < 4; comp++) {
comp              263 libavfilter/vf_noise.c         FilterParams *fp = &n->param[comp];
comp              431 libavfilter/vf_normalize.c     s->depth = desc->comp[0].depth;
comp              616 libavfilter/vf_overlay.c                 s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, s->main_desc->comp[0].step, is_straight, 1,
comp              619 libavfilter/vf_overlay.c                 s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, s->main_desc->comp[1].step, is_straight, 1,
comp              622 libavfilter/vf_overlay.c                 s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, s->main_desc->comp[2].step, is_straight, 1,
comp              645 libavfilter/vf_overlay.c                 s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, s->main_desc->comp[1].step, is_straight, 0,
comp              648 libavfilter/vf_overlay.c                 s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, s->main_desc->comp[2].step, is_straight, 0,
comp              651 libavfilter/vf_overlay.c                 s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, s->main_desc->comp[0].step, is_straight, 0,
comp               66 libavfilter/vf_overlay_opencl.c                             main_desc->comp[i].plane + 1);
comp               69 libavfilter/vf_overlay_opencl.c                                overlay_desc->comp[i].plane + 1);
comp              326 libavfilter/vf_owdenoise.c     s->pixel_depth = desc->comp[0].depth;
comp              140 libavfilter/vf_phase.c     switch (desc->comp[0].depth) {
comp              570 libavfilter/vf_premultiply.c     s->depth = desc->comp[0].depth;
comp              429 libavfilter/vf_pseudocolor.c     depth = desc->comp[0].depth;
comp              132 libavfilter/vf_psnr.c static void set_meta(AVDictionary **metadata, const char *key, char comp, float d)
comp              136 libavfilter/vf_psnr.c     if (comp) {
comp              138 libavfilter/vf_psnr.c         snprintf(key2, sizeof(key2), "%s%c", key, comp);
comp              303 libavfilter/vf_psnr.c     s->max[0] = (1 << desc->comp[0].depth) - 1;
comp              304 libavfilter/vf_psnr.c     s->max[1] = (1 << desc->comp[1].depth) - 1;
comp              305 libavfilter/vf_psnr.c     s->max[2] = (1 << desc->comp[2].depth) - 1;
comp              306 libavfilter/vf_psnr.c     s->max[3] = (1 << desc->comp[3].depth) - 1;
comp              328 libavfilter/vf_psnr.c     s->dsp.sse_line = desc->comp[0].depth > 8 ? sse_line_16bit : sse_line_8bit;
comp              330 libavfilter/vf_psnr.c         ff_psnr_init_x86(&s->dsp, desc->comp[0].depth);
comp              244 libavfilter/vf_remap.c     int depth = desc->comp[0].depth;
comp              305 libavfilter/vf_rotate.c     if (pixdesc->comp[0].depth == 8)
comp               93 libavfilter/vf_scdet.c     s->bitdepth = desc->comp[0].depth;
comp              167 libavfilter/vf_scroll.c     s->bytes = (s->desc->comp[0].depth + 7) >> 3;
comp              245 libavfilter/vf_selectivecolor.c     s->is_16bit = desc->comp[0].depth > 8;
comp              268 libavfilter/vf_showinfo.c     int bitdepth = desc->comp[0].depth;
comp              169 libavfilter/vf_signalstats.c     s->depth = desc->comp[0].depth;
comp              339 libavfilter/vf_spp.c     const int bps = desc->comp[0].depth;
comp              367 libavfilter/vf_spp.c     const int depth = desc->comp[0].depth;
comp               83 libavfilter/vf_ssim.c static void set_meta(AVDictionary **metadata, const char *key, char comp, float d)
comp               87 libavfilter/vf_ssim.c     if (comp) {
comp               89 libavfilter/vf_ssim.c         snprintf(key2, sizeof(key2), "%s%c", key, comp);
comp              413 libavfilter/vf_ssim.c     s->temp = av_mallocz_array(2 * SUM_LEN(inlink->w), (desc->comp[0].depth > 8) ? sizeof(int64_t[4]) : sizeof(int[4]));
comp              416 libavfilter/vf_ssim.c     s->max = (1 << desc->comp[0].depth) - 1;
comp              418 libavfilter/vf_ssim.c     s->ssim_plane = desc->comp[0].depth > 8 ? ssim_plane_16bit : ssim_plane;
comp               76 libavfilter/vf_swapuv.c         (desc->comp[1].depth != desc->comp[2].depth))
comp               79 libavfilter/vf_swapuv.c         if (desc->comp[i].offset != 0 ||
comp               80 libavfilter/vf_swapuv.c             desc->comp[i].shift != 0 ||
comp               81 libavfilter/vf_swapuv.c             desc->comp[i].plane != i)
comp              222 libavfilter/vf_threshold.c     s->depth = desc->comp[0].depth;
comp              237 libavfilter/vf_tinterlace.c             tinterlace->color.comp[0].u8[0] = 0;
comp              276 libavfilter/vf_tinterlace.c         if (tinterlace->csp->comp[0].depth > 8)
comp              283 libavfilter/vf_tinterlace.c         if (tinterlace->csp->comp[0].depth > 8)
comp              333 libavfilter/vf_tinterlace.c         int clip_max = (1 << tinterlace->csp->comp[plane].depth) - 1;
comp              356 libavfilter/vf_tinterlace.c             if (tinterlace->csp->comp[plane].depth > 8)
comp              133 libavfilter/vf_tonemap.c     const float *r_in = (const float *)(in->data[0] + x * desc->comp[0].step + y * in->linesize[0]);
comp              134 libavfilter/vf_tonemap.c     const float *b_in = (const float *)(in->data[1] + x * desc->comp[1].step + y * in->linesize[1]);
comp              135 libavfilter/vf_tonemap.c     const float *g_in = (const float *)(in->data[2] + x * desc->comp[2].step + y * in->linesize[2]);
comp              136 libavfilter/vf_tonemap.c     float *r_out = (float *)(out->data[0] + x * desc->comp[0].step + y * out->linesize[0]);
comp              137 libavfilter/vf_tonemap.c     float *b_out = (float *)(out->data[1] + x * desc->comp[1].step + y * out->linesize[1]);
comp              138 libavfilter/vf_tonemap.c     float *g_out = (float *)(out->data[2] + x * desc->comp[2].step + y * out->linesize[2]);
comp              288 libavfilter/vf_tonemap.c                 AV_WN32(out->data[3] + x * odesc->comp[3].step + y * out->linesize[3],
comp              120 libavfilter/vf_unsharp_opencl.c         ctx->nb_planes = FFMAX(ctx->nb_planes, desc->comp[p].plane + 1);
comp             3761 libavfilter/vf_v360.c     const int depth = desc->comp[0].depth;
comp              147 libavfilter/vf_vaguedenoiser.c     s->depth = desc->comp[0].depth;
comp              238 libavfilter/vf_vectorscope.c     depth = desc->comp[0].depth;
comp              242 libavfilter/vf_vectorscope.c             depth != desc->comp[0].depth)
comp             1487 libavfilter/vf_vectorscope.c     s->size = 1 << desc->comp[0].depth;
comp             1489 libavfilter/vf_vectorscope.c     s->depth = desc->comp[0].depth;
comp              201 libavfilter/vf_vibrance.c     s->depth = desc->comp[0].depth;
comp              256 libavfilter/vf_vmafmotion.c     vmafmotiondsp_init(&s->vmafdsp, desc->comp[0].depth);
comp              270 libavfilter/vf_vmafmotion.c             (!(desc->flags & AV_PIX_FMT_FLAG_BE) == !HAVE_BIGENDIAN || desc->comp[0].depth == 8) &&
comp              271 libavfilter/vf_vmafmotion.c             (desc->comp[0].depth == 8 || desc->comp[0].depth == 10) &&
comp              298 libavfilter/vf_w3fdif.c     depth = desc->comp[0].depth;
comp              351 libavfilter/vf_waveform.c     depth = desc->comp[0].depth;
comp              352 libavfilter/vf_waveform.c     depth2 = desc2->comp[0].depth;
comp              358 libavfilter/vf_waveform.c             depth != desc->comp[0].depth)
comp              689 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp              827 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp              964 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             1103 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             1246 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;                                                              \
comp             1386 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;                                                 \
comp             1532 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             1638 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             1742 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             1875 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             2007 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             2141 libavfilter/vf_waveform.c     const int plane = s->desc->comp[component].plane;
comp             3047 libavfilter/vf_waveform.c     s->bits = s->desc->comp[0].depth;
comp             3316 libavfilter/vf_waveform.c     int comp = 0, i, j = 0, k, p, size;
comp             3320 libavfilter/vf_waveform.c             comp++;
comp             3322 libavfilter/vf_waveform.c     s->acomp = comp;
comp             3332 libavfilter/vf_waveform.c         outlink->h = s->size * FFMAX(comp * (s->display == STACK), 1);
comp             3333 libavfilter/vf_waveform.c         outlink->w = inlink->w * FFMAX(comp * (s->display == PARADE), 1);
comp             3336 libavfilter/vf_waveform.c         outlink->w = s->size * FFMAX(comp * (s->display == STACK), 1);
comp             3337 libavfilter/vf_waveform.c         outlink->h = inlink->h * FFMAX(comp * (s->display == PARADE), 1);
comp             3346 libavfilter/vf_waveform.c         const int plane = s->desc->comp[p].plane;
comp             3392 libavfilter/vf_waveform.c                 memset(out->data[s->odesc->comp[k].plane] +
comp             3393 libavfilter/vf_waveform.c                        i * out->linesize[s->odesc->comp[k].plane],
comp             3397 libavfilter/vf_waveform.c             uint16_t *dst = (uint16_t *)out->data[s->odesc->comp[k].plane];
comp             3402 libavfilter/vf_waveform.c                 dst += out->linesize[s->odesc->comp[k].plane] / 2;
comp             3409 libavfilter/vf_waveform.c             const int plane = s->desc->comp[k].plane;
comp             1374 libavfilter/vf_xfade.c     s->depth = pix_desc->comp[0].depth;
comp               90 libavfilter/vf_xfade_opencl.c                             main_desc->comp[i].plane + 1);
comp              282 libavfilter/vf_xmedian.c     s->depth = s->desc->comp[0].depth;
comp              195 libavfilter/vf_yadif.c     int df = (s->csp->comp[td->plane].depth + 7) / 8;
comp              312 libavfilter/vf_yadif.c     if (s->csp->comp[0].depth > 8) {
comp              138 libavfilter/vf_yadif_cuda.c         const AVComponentDescriptor *comp = &y->csp->comp[i];
comp              140 libavfilter/vf_yadif_cuda.c         if (comp->plane < i) {
comp              146 libavfilter/vf_yadif_cuda.c         pixel_size = (comp->depth + comp->shift) / 8;
comp              147 libavfilter/vf_yadif_cuda.c         channels = comp->step / pixel_size;
comp              167 libavfilter/vf_yadif_cuda.c                comp->plane, pixel_size, channels);
comp              179 libavfilter/vf_yadif_cuda.c                     dst->linesize[i] / comp->step,
comp              275 libavfilter/vf_yaepblur.c     s->depth = desc->comp[0].depth;
comp              469 libavfilter/vf_zscale.c     format->depth = desc->comp[0].depth;
comp              470 libavfilter/vf_zscale.c     format->pixel_type = (desc->flags & AV_PIX_FMT_FLAG_FLOAT) ? ZIMG_PIXEL_FLOAT : desc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
comp              514 libavfilter/vf_zscale.c         int p = desc->comp[plane].plane;
comp              650 libavfilter/vf_zscale.c             s->alpha_src_format.depth = desc->comp[0].depth;
comp              651 libavfilter/vf_zscale.c             s->alpha_src_format.pixel_type = (desc->flags & AV_PIX_FMT_FLAG_FLOAT) ? ZIMG_PIXEL_FLOAT : desc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
comp              656 libavfilter/vf_zscale.c             s->alpha_dst_format.depth = odesc->comp[0].depth;
comp              657 libavfilter/vf_zscale.c             s->alpha_dst_format.pixel_type = (odesc->flags & AV_PIX_FMT_FLAG_FLOAT) ? ZIMG_PIXEL_FLOAT : odesc->comp[0].depth > 8 ? ZIMG_PIXEL_WORD : ZIMG_PIXEL_BYTE;
comp              687 libavfilter/vf_zscale.c         int p = desc->comp[plane].plane;
comp              692 libavfilter/vf_zscale.c         p = odesc->comp[plane].plane;
comp              724 libavfilter/vf_zscale.c                     AV_WN32(out->data[3] + x * odesc->comp[3].step + y * out->linesize[3],
comp              231 libavfilter/vsrc_gradients.c     s->draw_slice = desc->comp[0].depth == 16 ? draw_gradients_slice16 : draw_gradients_slice;
comp             1082 libavfilter/vsrc_testsrc.c     const int factor = 1 << desc->comp[0].depth;
comp             1083 libavfilter/vsrc_testsrc.c     const int mid = 1 << (desc->comp[0].depth - 1);
comp             1139 libavfilter/vsrc_testsrc.c     const int factor = 1 << desc->comp[0].depth;
comp             1140 libavfilter/vsrc_testsrc.c     const int mid = 1 << (desc->comp[0].depth - 1);
comp             1221 libavfilter/vsrc_testsrc.c     test->fill_picture_fn = desc->comp[0].depth > 8 ? yuvtest_fill_picture16 : yuvtest_fill_picture8;
comp              820 libavfilter/vulkan.c     const int high = desc->comp[0].depth > 8;
comp               53 libavfilter/vulkan.h #define GET_QUEUE_COUNT(hwctx, graph, comp, tx) (                   \
comp               55 libavfilter/vulkan.h     comp  ? (hwctx->nb_comp_queues ?                                \
comp               58 libavfilter/x86/vf_bwdif_init.c     int bit_depth = (!yadif->csp) ? 8 : yadif->csp->comp[0].depth;
comp               62 libavfilter/x86/vf_tinterlace_init.c     if (s->csp->comp[0].depth > 8) {
comp               64 libavfilter/x86/vf_yadif_init.c                                   : yadif->csp->comp[0].depth;
comp              190 libavformat/img2enc.c         if (desc->comp[0].depth >= 9) {
comp              889 libavformat/mux.c     int comp      = av_compare_ts(next->dts, st2->time_base, pkt->dts,
comp              905 libavformat/mux.c             comp = (ts2 > ts) - (ts2 < ts);
comp              909 libavformat/mux.c     if (comp == 0)
comp              911 libavformat/mux.c     return comp > 0;
comp             2479 libavformat/mxfenc.c                 sc->component_depth     = pix_desc->comp[0].depth;
comp              152 libavformat/vapoursynth.c             const AVComponentDescriptor *c = &pd->comp[i];
comp               62 libavformat/vpcc.c     return desc->comp[0].depth;
comp              864 libavutil/frame.c         const AVComponentDescriptor *comp = NULL;
comp              875 libavutil/frame.c             if (desc->comp[j].plane == i) {
comp              876 libavutil/frame.c                 comp = &desc->comp[j];
comp              880 libavutil/frame.c         if (!comp)
comp              884 libavutil/frame.c                      (frame->crop_left >> shift_x) * comp->step;
comp             1375 libavutil/hwcontext_opencl.c     const AVComponentDescriptor *comp;
comp             1398 libavutil/hwcontext_opencl.c         comp = &desc->comp[c];
comp             1399 libavutil/hwcontext_opencl.c         if (comp->plane != plane)
comp             1402 libavutil/hwcontext_opencl.c         if (comp->step != 1 && comp->step != 2 &&
comp             1403 libavutil/hwcontext_opencl.c             comp->step != 4 && comp->step != 8)
comp             1407 libavutil/hwcontext_opencl.c         if (comp->shift + comp->depth != 8 &&
comp             1408 libavutil/hwcontext_opencl.c             comp->shift + comp->depth != 16)
comp             1411 libavutil/hwcontext_opencl.c         if (depth && comp->depth != depth)
comp             1415 libavutil/hwcontext_opencl.c         if (comp->depth > 8 &&
comp             1420 libavutil/hwcontext_opencl.c         if (step && comp->step != step)
comp             1423 libavutil/hwcontext_opencl.c         depth = comp->depth;
comp             1424 libavutil/hwcontext_opencl.c         order = order * 10 + comp->offset / ((depth + 7) / 8) + 1;
comp             1425 libavutil/hwcontext_opencl.c         step  = comp->step;
comp              328 libavutil/hwcontext_qsv.c     surf->Info.BitDepthLuma   = desc->comp[0].depth;
comp              329 libavutil/hwcontext_qsv.c     surf->Info.BitDepthChroma = desc->comp[0].depth;
comp              330 libavutil/hwcontext_qsv.c     surf->Info.Shift          = desc->comp[0].depth > 8;
comp              107 libavutil/hwcontext_vulkan.c #define GET_QUEUE_COUNT(hwctx, graph, comp, tx) (                   \
comp              109 libavutil/hwcontext_vulkan.c     comp  ? (hwctx->nb_comp_queues ?                                \
comp              684 libavutil/hwcontext_vulkan.c #define ADD_QUEUE(fidx, graph, comp, tx)                                                 \
comp              687 libavutil/hwcontext_vulkan.c            comp ? "compute " : "", tx ? "transfers " : "");                              \
comp             2285 libavutil/hwcontext_vulkan.c     CUarray_format cufmt = desc->comp[0].depth > 8 ? CU_AD_FORMAT_UNSIGNED_INT16 :
comp             2442 libavutil/hwcontext_vulkan.c                                     : hwfc->width) * desc->comp[i].step,
comp             2947 libavutil/hwcontext_vulkan.c             .bufferRowLength = buf_stride[i] / desc->comp[i].step,
comp             3147 libavutil/hwcontext_vulkan.c                                     : hwfc->width) * desc->comp[i].step,
comp               44 libavutil/imgutils.c         const AVComponentDescriptor *comp = &(pixdesc->comp[i]);
comp               45 libavutil/imgutils.c         if (comp->step > max_pixsteps[comp->plane]) {
comp               46 libavutil/imgutils.c             max_pixsteps[comp->plane] = comp->step;
comp               48 libavutil/imgutils.c                 max_pixstep_comps[comp->plane] = i;
comp              134 libavutil/imgutils.c         has_plane[desc->comp[i].plane] = 1;
comp              368 libavutil/imgutils.c             planes_nb = FFMAX(planes_nb, desc->comp[i].plane + 1);
comp              468 libavutil/imgutils.c         nb_planes = FFMAX(desc->comp[i].plane, nb_planes);
comp              576 libavutil/imgutils.c         const AVComponentDescriptor comp = desc->comp[c];
comp              580 libavutil/imgutils.c         clear_block_size[comp.plane] = FFMAX(clear_block_size[comp.plane], comp.step);
comp              582 libavutil/imgutils.c         if (clear_block_size[comp.plane] > MAX_BLOCK_SIZE)
comp              588 libavutil/imgutils.c         const AVComponentDescriptor comp = desc->comp[c];
comp              590 libavutil/imgutils.c         int w = clear_block_size[comp.plane] / comp.step;
comp              597 libavutil/imgutils.c         if (comp.depth > 16)
comp              599 libavutil/imgutils.c         if (!rgb && comp.depth < 8)
comp              605 libavutil/imgutils.c             src = 16 << (comp.depth - 8);
comp              607 libavutil/imgutils.c             src = 128 << (comp.depth - 8);
comp              610 libavutil/imgutils.c             src = (1 << comp.depth) - 1;
comp               41 libavutil/pixdesc.c     AVComponentDescriptor comp = desc->comp[c];
comp               42 libavutil/pixdesc.c     int plane = comp.plane;
comp               43 libavutil/pixdesc.c     int depth = comp.depth;
comp               45 libavutil/pixdesc.c     int shift = comp.shift;
comp               46 libavutil/pixdesc.c     int step  = comp.step;
comp               52 libavutil/pixdesc.c         int skip = x * step + comp.offset;
comp               68 libavutil/pixdesc.c                            x * step + comp.offset;
comp              106 libavutil/pixdesc.c     AVComponentDescriptor comp = desc->comp[c];
comp              107 libavutil/pixdesc.c     int plane = comp.plane;
comp              108 libavutil/pixdesc.c     int depth = comp.depth;
comp              109 libavutil/pixdesc.c     int step  = comp.step;
comp              115 libavutil/pixdesc.c         int skip = x * step + comp.offset;
comp              126 libavutil/pixdesc.c         int shift = comp.shift;
comp              128 libavutil/pixdesc.c                      x * step + comp.offset;
comp              179 libavutil/pixdesc.c         .comp = {
comp              191 libavutil/pixdesc.c         .comp = {
comp              202 libavutil/pixdesc.c         .comp = {
comp              213 libavutil/pixdesc.c         .comp = {
comp              224 libavutil/pixdesc.c         .comp = {
comp              236 libavutil/pixdesc.c         .comp = {
comp              248 libavutil/pixdesc.c         .comp = {
comp              260 libavutil/pixdesc.c         .comp = {
comp              272 libavutil/pixdesc.c         .comp = {
comp              284 libavutil/pixdesc.c         .comp = {
comp              296 libavutil/pixdesc.c         .comp = {
comp              308 libavutil/pixdesc.c         .comp = {
comp              320 libavutil/pixdesc.c         .comp = {
comp              331 libavutil/pixdesc.c         .comp = {
comp              341 libavutil/pixdesc.c         .comp = {
comp              351 libavutil/pixdesc.c         .comp = {
comp              361 libavutil/pixdesc.c         .comp = {
comp              373 libavutil/pixdesc.c         .comp = {
comp              385 libavutil/pixdesc.c         .comp = {
comp              401 libavutil/pixdesc.c         .comp = {
comp              412 libavutil/pixdesc.c         .comp = {
comp              423 libavutil/pixdesc.c         .comp = {
comp              435 libavutil/pixdesc.c         .comp = {
comp              447 libavutil/pixdesc.c         .comp = {
comp              459 libavutil/pixdesc.c         .comp = {
comp              471 libavutil/pixdesc.c         .comp = {
comp              483 libavutil/pixdesc.c         .comp = {
comp              495 libavutil/pixdesc.c         .comp = {
comp              507 libavutil/pixdesc.c         .comp = {
comp              519 libavutil/pixdesc.c         .comp = {
comp              532 libavutil/pixdesc.c         .comp = {
comp              545 libavutil/pixdesc.c         .comp = {
comp              558 libavutil/pixdesc.c         .comp = {
comp              571 libavutil/pixdesc.c         .comp = {
comp              583 libavutil/pixdesc.c         .comp = {
comp              595 libavutil/pixdesc.c         .comp = {
comp              607 libavutil/pixdesc.c         .comp = {
comp              619 libavutil/pixdesc.c         .comp = {
comp              630 libavutil/pixdesc.c         .comp = {
comp              640 libavutil/pixdesc.c         .comp = {
comp              651 libavutil/pixdesc.c         .comp = {
comp              661 libavutil/pixdesc.c         .comp = {
comp              672 libavutil/pixdesc.c         .comp = {
comp              682 libavutil/pixdesc.c         .comp = {
comp              693 libavutil/pixdesc.c         .comp = {
comp              703 libavutil/pixdesc.c         .comp = {
comp              714 libavutil/pixdesc.c         .comp = {
comp              724 libavutil/pixdesc.c         .comp = {
comp              736 libavutil/pixdesc.c         .comp = {
comp              748 libavutil/pixdesc.c         .comp = {
comp              760 libavutil/pixdesc.c         .comp = {
comp              772 libavutil/pixdesc.c         .comp = {
comp              784 libavutil/pixdesc.c         .comp = {
comp              796 libavutil/pixdesc.c         .comp = {
comp              809 libavutil/pixdesc.c         .comp = {
comp              822 libavutil/pixdesc.c         .comp = {
comp              835 libavutil/pixdesc.c         .comp = {
comp              848 libavutil/pixdesc.c         .comp = {
comp              861 libavutil/pixdesc.c         .comp = {
comp              874 libavutil/pixdesc.c         .comp = {
comp              887 libavutil/pixdesc.c         .comp = {
comp              900 libavutil/pixdesc.c         .comp = {
comp              913 libavutil/pixdesc.c         .comp = {
comp              926 libavutil/pixdesc.c         .comp = {
comp              939 libavutil/pixdesc.c         .comp = {
comp              952 libavutil/pixdesc.c         .comp = {
comp              965 libavutil/pixdesc.c         .comp = {
comp              978 libavutil/pixdesc.c         .comp = {
comp              991 libavutil/pixdesc.c         .comp = {
comp             1004 libavutil/pixdesc.c         .comp = {
comp             1017 libavutil/pixdesc.c         .comp = {
comp             1030 libavutil/pixdesc.c         .comp = {
comp             1043 libavutil/pixdesc.c         .comp = {
comp             1056 libavutil/pixdesc.c         .comp = {
comp             1069 libavutil/pixdesc.c         .comp = {
comp             1081 libavutil/pixdesc.c         .comp = {
comp             1093 libavutil/pixdesc.c         .comp = {
comp             1106 libavutil/pixdesc.c         .comp = {
comp             1119 libavutil/pixdesc.c         .comp = {
comp             1131 libavutil/pixdesc.c         .comp = {
comp             1143 libavutil/pixdesc.c         .comp = {
comp             1155 libavutil/pixdesc.c         .comp = {
comp             1167 libavutil/pixdesc.c         .comp = {
comp             1179 libavutil/pixdesc.c         .comp = {
comp             1191 libavutil/pixdesc.c         .comp = {
comp             1203 libavutil/pixdesc.c         .comp = {
comp             1215 libavutil/pixdesc.c         .comp = {
comp             1228 libavutil/pixdesc.c         .comp = {
comp             1241 libavutil/pixdesc.c         .comp = {
comp             1253 libavutil/pixdesc.c         .comp = {
comp             1265 libavutil/pixdesc.c         .comp = {
comp             1277 libavutil/pixdesc.c         .comp = {
comp             1289 libavutil/pixdesc.c         .comp = {
comp             1301 libavutil/pixdesc.c         .comp = {
comp             1340 libavutil/pixdesc.c         .comp = {
comp             1352 libavutil/pixdesc.c         .comp = {
comp             1364 libavutil/pixdesc.c         .comp = {
comp             1376 libavutil/pixdesc.c         .comp = {
comp             1388 libavutil/pixdesc.c         .comp = {
comp             1400 libavutil/pixdesc.c         .comp = {
comp             1412 libavutil/pixdesc.c         .comp = {
comp             1424 libavutil/pixdesc.c         .comp = {
comp             1436 libavutil/pixdesc.c         .comp = {
comp             1448 libavutil/pixdesc.c         .comp = {
comp             1460 libavutil/pixdesc.c         .comp = {
comp             1472 libavutil/pixdesc.c         .comp = {
comp             1484 libavutil/pixdesc.c         .comp = {
comp             1496 libavutil/pixdesc.c         .comp = {
comp             1508 libavutil/pixdesc.c         .comp = {
comp             1520 libavutil/pixdesc.c         .comp = {
comp             1532 libavutil/pixdesc.c         .comp = {
comp             1544 libavutil/pixdesc.c         .comp = {
comp             1556 libavutil/pixdesc.c         .comp = {
comp             1568 libavutil/pixdesc.c         .comp = {
comp             1580 libavutil/pixdesc.c         .comp = {
comp             1592 libavutil/pixdesc.c         .comp = {
comp             1604 libavutil/pixdesc.c         .comp = {
comp             1616 libavutil/pixdesc.c         .comp = {
comp             1628 libavutil/pixdesc.c         .comp = {
comp             1640 libavutil/pixdesc.c         .comp = {
comp             1652 libavutil/pixdesc.c         .comp = {
comp             1664 libavutil/pixdesc.c         .comp = {
comp             1676 libavutil/pixdesc.c         .comp = {
comp             1688 libavutil/pixdesc.c         .comp = {
comp             1710 libavutil/pixdesc.c         .comp = {
comp             1720 libavutil/pixdesc.c         .comp = {
comp             1729 libavutil/pixdesc.c         .comp = {
comp             1744 libavutil/pixdesc.c         .comp = {
comp             1756 libavutil/pixdesc.c         .comp = {
comp             1768 libavutil/pixdesc.c         .comp = {
comp             1780 libavutil/pixdesc.c         .comp = {
comp             1792 libavutil/pixdesc.c         .comp = {
comp             1804 libavutil/pixdesc.c         .comp = {
comp             1816 libavutil/pixdesc.c         .comp = {
comp             1828 libavutil/pixdesc.c         .comp = {
comp             1840 libavutil/pixdesc.c         .comp = {
comp             1852 libavutil/pixdesc.c         .comp = {
comp             1864 libavutil/pixdesc.c         .comp = {
comp             1876 libavutil/pixdesc.c         .comp = {
comp             1890 libavutil/pixdesc.c         .comp = {
comp             1904 libavutil/pixdesc.c         .comp = {
comp             1924 libavutil/pixdesc.c         .comp = {
comp             1936 libavutil/pixdesc.c         .comp = {
comp             1948 libavutil/pixdesc.c         .comp = {          \
comp             1958 libavutil/pixdesc.c         .comp = {          \
comp             2029 libavutil/pixdesc.c         .comp = {
comp             2041 libavutil/pixdesc.c         .comp = {
comp             2053 libavutil/pixdesc.c         .comp = {
comp             2081 libavutil/pixdesc.c         .comp = {
comp             2094 libavutil/pixdesc.c         .comp = {
comp             2107 libavutil/pixdesc.c         .comp = {
comp             2119 libavutil/pixdesc.c         .comp = {
comp             2131 libavutil/pixdesc.c         .comp = {
comp             2143 libavutil/pixdesc.c         .comp = {
comp             2155 libavutil/pixdesc.c         .comp = {
comp             2169 libavutil/pixdesc.c         .comp = {
comp             2183 libavutil/pixdesc.c         .comp = {
comp             2197 libavutil/pixdesc.c         .comp = {
comp             2215 libavutil/pixdesc.c         .comp = {
comp             2228 libavutil/pixdesc.c         .comp = {
comp             2240 libavutil/pixdesc.c         .comp = {
comp             2255 libavutil/pixdesc.c         .comp = {
comp             2277 libavutil/pixdesc.c         .comp = {
comp             2288 libavutil/pixdesc.c         .comp = {
comp             2299 libavutil/pixdesc.c         .comp = {
comp             2312 libavutil/pixdesc.c         .comp = {
comp             2325 libavutil/pixdesc.c         .comp = {
comp             2338 libavutil/pixdesc.c         .comp = {
comp             2351 libavutil/pixdesc.c         .comp = {
comp             2363 libavutil/pixdesc.c         .comp = {
comp             2508 libavutil/pixdesc.c         bits += pixdesc->comp[c].depth << s;
comp             2521 libavutil/pixdesc.c         const AVComponentDescriptor *comp = &pixdesc->comp[c];
comp             2523 libavutil/pixdesc.c         steps[comp->plane] = comp->step << s;
comp             2598 libavutil/pixdesc.c         planes[desc->comp[i].plane] = 1;
comp             2623 libavutil/pixdesc.c         for (j=0; j<FF_ARRAY_ELEMS(d->comp); j++) {
comp             2624 libavutil/pixdesc.c             const AVComponentDescriptor *c = &d->comp[j];
comp             2708 libavutil/pixdesc.c         *min = FFMIN(desc->comp[i].depth, *min);
comp             2709 libavutil/pixdesc.c         *max = FFMAX(desc->comp[i].depth, *max);
comp             2755 libavutil/pixdesc.c         int depth_minus1 = (dst_pix_fmt == AV_PIX_FMT_PAL8) ? 7/nb_components : (dst_desc->comp[i].depth - 1);
comp             2756 libavutil/pixdesc.c         if (src_desc->comp[i].depth - 1 > depth_minus1 && (consider & FF_LOSS_DEPTH)) {
comp             2806 libavutil/pixdesc.c         score -= (nb_components * 65536) >> FFMIN(dst_desc->comp[0].depth - 1, src_desc->comp[0].depth - 1);
comp              117 libavutil/pixdesc.h     AVComponentDescriptor comp[4];
comp               39 libavutil/tests/lzo.c     uint8_t *comp = av_malloc(2*MAXSZ + 16);
comp               48 libavutil/tests/lzo.c         lzo1x_1_compress(orig, s, comp, &clen, tmp);
comp               50 libavutil/tests/lzo.c         lzo1x_1_11_compress(orig, s, comp, &clen, tmp);
comp               52 libavutil/tests/lzo.c         lzo1x_1_12_compress(orig, s, comp, &clen, tmp);
comp               54 libavutil/tests/lzo.c         lzo1x_1_15_compress(orig, s, comp, &clen, tmp);
comp               56 libavutil/tests/lzo.c         lzo1x_999_compress(orig, s, comp, &clen, tmp);
comp               61 libavutil/tests/lzo.c         if (lzo1x_decompress_safe(comp, inlen, decomp, &outlen, NULL))
comp               63 libavutil/tests/lzo.c         if (lzo1x_decompress(comp, inlen, decomp, &outlen, NULL))
comp               65 libavutil/tests/lzo.c         if (av_lzo1x_decode(decomp, &outlen, comp, &inlen))
comp               76 libavutil/tests/lzo.c     av_free(comp);
comp              941 libswresample/swresample.c                 int comp = av_clipf(fdelta, -max_soft_compensation, max_soft_compensation) * duration ;
comp              942 libswresample/swresample.c                 av_log(s, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n", fdelta, comp, duration);
comp              943 libswresample/swresample.c                 swr_set_compensation(s, comp, duration);
comp               31 libswscale/alphablend.c     int sixteen_bits = desc->comp[0].depth >= 9;
comp               32 libswscale/alphablend.c     unsigned off    = 1<<(desc->comp[0].depth - 1);
comp               33 libswscale/alphablend.c     unsigned shift  = desc->comp[0].depth;
comp               40 libswscale/alphablend.c             a = (1<<(desc->comp[0].depth - 1))/2;
comp               41 libswscale/alphablend.c             b = 3*(1<<(desc->comp[0].depth-1))/2;
comp               43 libswscale/alphablend.c         target_table[0][plane] = plane && !(desc->flags & AV_PIX_FMT_FLAG_RGB) ? 1<<(desc->comp[0].depth - 1) : a;
comp               44 libswscale/alphablend.c         target_table[1][plane] = plane && !(desc->flags & AV_PIX_FMT_FLAG_RGB) ? 1<<(desc->comp[0].depth - 1) : b;
comp              128 libswscale/alphablend.c         int alpha_pos = desc->comp[plane_count].offset;
comp             2170 libswscale/output.c     int SH = 22 + 8 - desc->comp[0].depth;
comp             2556 libswscale/output.c         if (desc->comp[0].depth == 9) {
comp             2559 libswscale/output.c         } else if (desc->comp[0].depth == 10) {
comp             2562 libswscale/output.c         } else if (desc->comp[0].depth == 12) {
comp             2565 libswscale/output.c         } else if (desc->comp[0].depth == 14) {
comp             1926 libswscale/ppc/swscale_vsx.c     int bits            = desc->comp[0].depth - 1;
comp             1951 libswscale/ppc/swscale_vsx.c     if ((isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
comp             2003 libswscale/ppc/swscale_vsx.c     int sh              = desc->comp[0].depth - 1;
comp             2028 libswscale/ppc/swscale_vsx.c         sh = isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
comp               74 libswscale/swscale.c     int bits            = desc->comp[0].depth - 1;
comp               77 libswscale/swscale.c     if ((isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8) && desc->comp[0].depth<16) {
comp              103 libswscale/swscale.c     int sh              = desc->comp[0].depth - 1;
comp              106 libswscale/swscale.c         sh = isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 : (desc->comp[0].depth - 1);
comp              501 libswscale/swscale.c                     1, desc->comp[3].depth,
comp              506 libswscale/swscale.c                     1, desc->comp[3].depth,
comp              620 libswscale/swscale.c         int plane = desc->comp[i].plane;
comp              647 libswscale/swscale_internal.h     return desc->comp[0].depth == 16;
comp              654 libswscale/swscale_internal.h     return desc->comp[0].depth == 32;
comp              661 libswscale/swscale_internal.h     return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
comp              693 libswscale/swscale_internal.h     return (isPlanarYUV(pix_fmt) && desc->comp[1].plane == desc->comp[2].plane);
comp              238 libswscale/swscale_unscaled.c         dst_format->comp[0].depth + dst_format->comp[0].shift -
comp              239 libswscale/swscale_unscaled.c         src_format->comp[0].depth - src_format->comp[0].shift,
comp              240 libswscale/swscale_unscaled.c         dst_format->comp[1].depth + dst_format->comp[1].shift -
comp              241 libswscale/swscale_unscaled.c         src_format->comp[1].depth - src_format->comp[1].shift,
comp              242 libswscale/swscale_unscaled.c         dst_format->comp[2].depth + dst_format->comp[2].shift -
comp              243 libswscale/swscale_unscaled.c         src_format->comp[2].depth - src_format->comp[2].shift,
comp              712 libswscale/swscale_unscaled.c     int bpc = dst_format->comp[0].depth;
comp              891 libswscale/swscale_unscaled.c     int bits_per_sample = src_format->comp[0].depth;
comp             1774 libswscale/swscale_unscaled.c                         plane == 3, desc_dst->comp[plane].depth,
comp             1784 libswscale/swscale_unscaled.c                 const int src_depth = desc_src->comp[plane].depth;
comp             1785 libswscale/swscale_unscaled.c                 const int dst_depth = desc_dst->comp[plane].depth;
comp             1908 libswscale/swscale_unscaled.c                 else if (desc_src->comp[0].depth == 1)
comp             2043 libswscale/swscale_unscaled.c     if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
comp             1422 libswscale/utils.c     c->srcBpc = desc_src->comp[0].depth;
comp             1425 libswscale/utils.c     c->dstBpc = desc_dst->comp[0].depth;
comp              413 libswscale/x86/swscale.c     } else if (c->srcBpc == 14 || ((c->srcFormat==AV_PIX_FMT_PAL8||isAnyRGB(c->srcFormat)) && av_pix_fmt_desc_get(c->srcFormat)->comp[0].depth<16)) { \