replace remaining PIX_FMT_* flags with AV_PIX_FMT_FLAG_*

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>

libavcodec/dpxenc.c

@@ -37,10 +37,10 @@ static av_cold int encode_init(AVCodecContext *avctx)
     DPXContext *s = avctx->priv_data;
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
 
-    s->big_endian         = !!(desc->flags & PIX_FMT_BE);
+    s->big_endian         = !!(desc->flags & AV_PIX_FMT_FLAG_BE);
     s->bits_per_component = desc->comp[0].depth_minus1 + 1;
-    s->descriptor         = (desc->flags & PIX_FMT_ALPHA) ? 51 : 50;
-    s->planar             = !!(desc->flags & PIX_FMT_PLANAR);
+    s->descriptor         = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? 51 : 50;
+    s->planar             = !!(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
 
     switch (avctx->pix_fmt) {
     case AV_PIX_FMT_GBRP10BE:

libavcodec/imgconvert.c

@@ -59,7 +59,7 @@
 #endif
 
 #define pixdesc_has_alpha(pixdesc) \
-    ((pixdesc)->nb_components == 2 || (pixdesc)->nb_components == 4 || (pixdesc)->flags & PIX_FMT_PAL)
+    ((pixdesc)->nb_components == 2 || (pixdesc)->nb_components == 4 || (pixdesc)->flags & AV_PIX_FMT_FLAG_PAL)
 
 
 void avcodec_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
@@ -654,7 +654,7 @@ int main(void){
             skip = 0;
         }
         av_log(NULL, AV_LOG_INFO, "pix fmt %s yuv_plan:%d avg_bpp:%d colortype:%d\n", desc->name, is_yuv_planar(desc), av_get_padded_bits_per_pixel(desc), get_color_type(desc));
-        if ((!(desc->flags & PIX_FMT_ALPHA)) != (desc->nb_components != 2 && desc->nb_components != 4)) {
+        if ((!(desc->flags & AV_PIX_FMT_FLAG_ALPHA)) != (desc->nb_components != 2 && desc->nb_components != 4)) {
             av_log(NULL, AV_LOG_ERROR, "Alpha flag mismatch\n");
             err = 1;
         }

libavcodec/utils.c

@@ -568,7 +568,7 @@ void avpriv_color_frame(AVFrame *frame, const int c[4])
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
     int p, y, x;
 
-    av_assert0(desc->flags & PIX_FMT_PLANAR);
+    av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
 
     for (p = 0; p<desc->nb_components; p++) {
         uint8_t *dst = frame->data[p];

libavdevice/lavfi.c

@@ -60,7 +60,7 @@ static int *create_all_formats(int n)
 
     for (i = 0; i < n; i++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
-        if (!(desc->flags & PIX_FMT_HWACCEL))
+        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
             count++;
     }
 
@@ -68,7 +68,7 @@ static int *create_all_formats(int n)
         return NULL;
     for (j = 0, i = 0; i < n; i++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(i);
-        if (!(desc->flags & PIX_FMT_HWACCEL))
+        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
             fmts[j++] = i;
     }
     fmts[j] = -1;

libavfilter/drawutils.c

@@ -151,7 +151,7 @@ int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
 
     if (!desc->name)
         return AVERROR(EINVAL);
-    if (desc->flags & ~(PIX_FMT_PLANAR | PIX_FMT_RGB | PIX_FMT_PSEUDOPAL | PIX_FMT_ALPHA))
+    if (desc->flags & ~(AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_PSEUDOPAL | AV_PIX_FMT_FLAG_ALPHA))
         return AVERROR(ENOSYS);
     for (i = 0; i < desc->nb_components; i++) {
         c = &desc->comp[i];
@@ -176,7 +176,7 @@ int ff_draw_init(FFDrawContext *draw, enum AVPixelFormat format, unsigned flags)
     draw->format    = format;
     draw->nb_planes = nb_planes;
     memcpy(draw->pixelstep, pixelstep, sizeof(draw->pixelstep));
-    if (nb_planes >= 3 && !(desc->flags & PIX_FMT_RGB)) {
+    if (nb_planes >= 3 && !(desc->flags & AV_PIX_FMT_FLAG_RGB)) {
         draw->hsub[1] = draw->hsub[2] = draw->hsub_max = desc->log2_chroma_w;
         draw->vsub[1] = draw->vsub[2] = draw->vsub_max = desc->log2_chroma_h;
     }
@@ -193,7 +193,7 @@ void ff_draw_color(FFDrawContext *draw, FFDrawColor *color, const uint8_t rgba[4
 
     if (rgba != color->rgba)
         memcpy(color->rgba, rgba, sizeof(color->rgba));
-    if ((draw->desc->flags & PIX_FMT_RGB) && draw->nb_planes == 1 &&
+    if ((draw->desc->flags & AV_PIX_FMT_FLAG_RGB) && draw->nb_planes == 1 &&
         ff_fill_rgba_map(rgba_map, draw->format) >= 0) {
         for (i = 0; i < 4; i++)
             color->comp[0].u8[rgba_map[i]] = rgba[i];

libavfilter/formats.c

@@ -112,10 +112,10 @@ AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
             for (j = 0; j < b->format_count; j++) {
                 const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
                 const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
-                alpha2 |= adesc->flags & bdesc->flags & PIX_FMT_ALPHA;
+                alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
                 chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
                 if (a->formats[i] == b->formats[j]) {
-                    alpha1 |= adesc->flags & PIX_FMT_ALPHA;
+                    alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
                     chroma1|= adesc->nb_components > 1;
                 }
             }

libavfilter/vf_extractplanes.c

@@ -110,11 +110,11 @@ static int query_formats(AVFilterContext *ctx)
     avff = ctx->inputs[0]->in_formats;
     desc = av_pix_fmt_desc_get(avff->formats[0]);
     depth = desc->comp[0].depth_minus1;
-    be = desc->flags & PIX_FMT_BE;
+    be = desc->flags & AV_PIX_FMT_FLAG_BE;
     for (i = 1; i < avff->format_count; i++) {
         desc = av_pix_fmt_desc_get(avff->formats[i]);
         if (depth != desc->comp[0].depth_minus1 ||
-            be    != (desc->flags & PIX_FMT_BE)) {
+            be    != (desc->flags & AV_PIX_FMT_FLAG_BE)) {
             return AVERROR(EAGAIN);
         }
     }
@@ -139,10 +139,10 @@ static int config_input(AVFilterLink *inlink)
     int plane_avail, ret, i;
     uint8_t rgba_map[4];
 
-    plane_avail = ((desc->flags & PIX_FMT_RGB) ? PLANE_R|PLANE_G|PLANE_B :
+    plane_avail = ((desc->flags & AV_PIX_FMT_FLAG_RGB) ? PLANE_R|PLANE_G|PLANE_B :
                                                  PLANE_Y |
                                 ((desc->nb_components > 2) ? PLANE_U|PLANE_V : 0)) |
-                  ((desc->flags & PIX_FMT_ALPHA) ? PLANE_A : 0);
+                  ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? PLANE_A : 0);
     if (e->requested_planes & ~plane_avail) {
         av_log(ctx, AV_LOG_ERROR, "Requested planes not available.\n");
         return AVERROR(EINVAL);
@@ -152,8 +152,8 @@ static int config_input(AVFilterLink *inlink)
 
     e->depth = (desc->comp[0].depth_minus1 + 1) >> 3;
     e->step = av_get_padded_bits_per_pixel(desc) >> 3;
-    e->is_packed_rgb = !(desc->flags & PIX_FMT_PLANAR);
-    if (desc->flags & PIX_FMT_RGB) {
+    e->is_packed_rgb = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
+    if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
         ff_fill_rgba_map(rgba_map, inlink->format);
         for (i = 0; i < 4; i++)
             e->map[i] = rgba_map[e->map[i]];

libavfilter/vf_fade.c

@@ -127,7 +127,7 @@ static int config_props(AVFilterLink *inlink)
     fade->vsub = pixdesc->log2_chroma_h;
 
     fade->bpp = av_get_bits_per_pixel(pixdesc) >> 3;
-    fade->alpha &= pixdesc->flags & PIX_FMT_ALPHA;
+    fade->alpha &= pixdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
     fade->is_packed_rgb = ff_fill_rgba_map(fade->rgba_map, inlink->format) >= 0;
 
     /* use CCIR601/709 black level for studio-level pixel non-alpha components */

libavfilter/vf_hflip.c

@@ -47,8 +47,8 @@ static int query_formats(AVFilterContext *ctx)
 
     for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
-        if (!(desc->flags & PIX_FMT_HWACCEL ||
-              desc->flags & PIX_FMT_BITSTREAM ||
+        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
+              desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ||
               (desc->log2_chroma_w != desc->log2_chroma_h &&
                desc->comp[0].plane == desc->comp[1].plane)))
             ff_add_format(&pix_fmts, fmt);
@@ -87,7 +87,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *in)
     av_frame_copy_props(out, in);
 
     /* copy palette if required */
-    if (av_pix_fmt_desc_get(inlink->format)->flags & PIX_FMT_PAL)
+    if (av_pix_fmt_desc_get(inlink->format)->flags & AV_PIX_FMT_FLAG_PAL)
         memcpy(out->data[1], in->data[1], AVPALETTE_SIZE);
 
     for (plane = 0; plane < 4 && in->data[plane]; plane++) {

libavfilter/vf_il.c

@@ -88,7 +88,7 @@ static int query_formats(AVFilterContext *ctx)
 
     for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
-        if (!(desc->flags & PIX_FMT_PAL) && !(desc->flags & PIX_FMT_HWACCEL))
+        if (!(desc->flags & AV_PIX_FMT_FLAG_PAL) && !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
             ff_add_format(&formats, fmt);
     }
 
@@ -106,7 +106,7 @@ static int config_input(AVFilterLink *inlink)
         il->nb_planes = FFMAX(il->nb_planes, desc->comp[i].plane);
     il->nb_planes++;
 
-    il->has_alpha = !!(desc->flags & PIX_FMT_ALPHA);
+    il->has_alpha = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
     if ((ret = av_image_fill_linesizes(il->linesize, inlink->format, inlink->w)) < 0)
         return ret;
 

libavfilter/vf_kerndeint.c

@@ -89,7 +89,7 @@ static int config_props(AVFilterLink *inlink)
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
     int ret;
 
-    kerndeint->is_packed_rgb = av_pix_fmt_desc_get(inlink->format)->flags & PIX_FMT_RGB;
+    kerndeint->is_packed_rgb = av_pix_fmt_desc_get(inlink->format)->flags & AV_PIX_FMT_FLAG_RGB;
     kerndeint->vsub = desc->log2_chroma_h;
 
     ret = av_image_alloc(kerndeint->tmp_data, kerndeint->tmp_linesize,

libavfilter/vf_noise.c

@@ -172,7 +172,7 @@ static int query_formats(AVFilterContext *ctx)
 
     for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
-        if (desc->flags & PIX_FMT_PLANAR && !((desc->comp[0].depth_minus1 + 1) & 7))
+        if (desc->flags & AV_PIX_FMT_FLAG_PLANAR && !((desc->comp[0].depth_minus1 + 1) & 7))
             ff_add_format(&formats, fmt);
     }
 

libavfilter/vf_swapuv.c

@@ -54,7 +54,7 @@ static int is_planar_yuv(const AVPixFmtDescriptor *desc)
 {
     int i;
 
-    if (desc->flags & ~(PIX_FMT_BE | PIX_FMT_PLANAR | PIX_FMT_ALPHA) ||
+    if (desc->flags & ~(AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_ALPHA) ||
         desc->nb_components < 3 ||
         (desc->comp[1].depth_minus1 != desc->comp[2].depth_minus1))
         return 0;

libavfilter/vf_telecine.c

@@ -103,7 +103,7 @@ static int query_formats(AVFilterContext *ctx)
 
     for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
-        if (!(desc->flags & PIX_FMT_HWACCEL))
+        if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
             ff_add_format(&pix_fmts, fmt);
     }
 

libavfilter/vf_transpose.c

@@ -67,9 +67,9 @@ static int query_formats(AVFilterContext *ctx)
 
     for (fmt = 0; fmt < AV_PIX_FMT_NB; fmt++) {
         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
-        if (!(desc->flags & PIX_FMT_PAL ||
-              desc->flags & PIX_FMT_HWACCEL ||
-              desc->flags & PIX_FMT_BITSTREAM ||
+        if (!(desc->flags & AV_PIX_FMT_FLAG_PAL ||
+              desc->flags & AV_PIX_FMT_FLAG_HWACCEL ||
+              desc->flags & AV_PIX_FMT_FLAG_BITSTREAM ||
               desc->log2_chroma_w != desc->log2_chroma_h))
             ff_add_format(&pix_fmts, fmt);
     }

libavformat/img2enc.c

@@ -60,7 +60,7 @@ static int write_header(AVFormatContext *s)
                          && s->nb_streams == 1
                          && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO
                          && desc
-                         &&(desc->flags & PIX_FMT_PLANAR)
+                         &&(desc->flags & AV_PIX_FMT_FLAG_PLANAR)
                          && desc->nb_components >= 3;
     return 0;
 }

libavutil/imgutils.c

@@ -76,7 +76,7 @@ int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
     int max_step     [4];       /* max pixel step for each plane */
     int max_step_comp[4];       /* the component for each plane which has the max pixel step */
 
-    if ((unsigned)pix_fmt >= AV_PIX_FMT_NB || desc->flags & PIX_FMT_HWACCEL)
+    if ((unsigned)pix_fmt >= AV_PIX_FMT_NB || desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
         return AVERROR(EINVAL);
 
     av_image_fill_max_pixsteps(max_step, max_step_comp, desc);
@@ -324,7 +324,7 @@ int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height,
         return AVERROR(EINVAL);
     if (av_image_check_size(width, height, 0, NULL) < 0)
         return AVERROR(EINVAL);
-    if (desc->flags & PIX_FMT_PSEUDOPAL)
+    if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
         // do not include palette for these pseudo-paletted formats
         return width * height;
     return av_image_fill_arrays(data, linesize, NULL, pix_fmt, width, height, align);
@@ -358,7 +358,7 @@ int av_image_copy_to_buffer(uint8_t *dst, int dst_size,
         }
     }
 
-    if (desc->flags & PIX_FMT_PAL) {
+    if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
         uint32_t *d32 = (uint32_t *)(((size_t)dst + 3) & ~3);
         for (i = 0; i<256; i++)
             AV_WL32(d32 + i, AV_RN32(src_data[1] + 4*i));

libswscale/output.c

@@ -1717,7 +1717,7 @@ yuv2gbrp_full_X_c(SwsContext *c, const int16_t *lumFilter,
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
     int i;
-    int hasAlpha = (desc->flags & PIX_FMT_ALPHA) && alpSrc;
+    int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrc;
     uint16_t **dest16 = (uint16_t**)dest;
     int SH = 22 + 7 - desc->comp[0].depth_minus1;
     int A = 0; // init to silence warning

libswscale/swscale.c

@@ -804,7 +804,7 @@ static void xyz12Torgb48(struct SwsContext *c, uint16_t *dst,
         for (xp=0; xp+2<stride; xp+=3) {
             int x, y, z, r, g, b;
 
-            if (desc->flags & PIX_FMT_BE) {
+            if (desc->flags & AV_PIX_FMT_FLAG_BE) {
                 x = AV_RB16(src + xp + 0);
                 y = AV_RB16(src + xp + 1);
                 z = AV_RB16(src + xp + 2);
@@ -835,7 +835,7 @@ static void xyz12Torgb48(struct SwsContext *c, uint16_t *dst,
             b = av_clip_c(b,0,4095);
 
             // convert from sRGBlinear to RGB and scale from 12bit to 16bit
-            if (desc->flags & PIX_FMT_BE) {
+            if (desc->flags & AV_PIX_FMT_FLAG_BE) {
                 AV_WB16(dst + xp + 0, c->rgbgamma[r] << 4);
                 AV_WB16(dst + xp + 1, c->rgbgamma[g] << 4);
                 AV_WB16(dst + xp + 2, c->rgbgamma[b] << 4);

libswscale/swscale_internal.h

@@ -742,7 +742,7 @@ static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
 {
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
     av_assert0(desc);
-    return desc->flags & PIX_FMT_ALPHA;
+    return desc->flags & AV_PIX_FMT_FLAG_ALPHA;
 }
 
 #if 1

tools/fourcc2pixfmt.c

@@ -102,7 +102,7 @@ int main(int argc, char **argv)
     if (list_pix_fmt_fourccs) {
         for (i = 0; i < AV_PIX_FMT_NB; i++) {
             const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(i);
-            if (!pix_desc->name || pix_desc->flags & PIX_FMT_HWACCEL)
+            if (!pix_desc->name || pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
                 continue;
             printf("%s: ", pix_desc->name);
             print_pix_fmt_fourccs(i, ' ');