Showing the changes to libavfilter (13 of 13 files). Show all
Unified · Split
| @@ -111,7 +111,7 @@ static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx) · 110 unmodified lines | ||
| 111 | 111 | * @param color color of the arrow |
| 112 | 112 | */ |
| 113 | 113 | static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, |
| 114 | − int w, int h, int stride, int color) | |
| 114 | + int w, int h, ptrdiff_t stride, int color) | |
| 115 | 115 | { |
| 116 | 116 | int x, y, fr, f; |
| 117 | 117 | |
| @@ -169,7 +169,7 @@ static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, · 51 unmodified lines | ||
| 169 | 169 | * @param color color of the arrow |
| 170 | 170 | */ |
| 171 | 171 | static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, |
| 172 | − int ey, int w, int h, int stride, int color, int tail, int direction) | |
| 172 | + int ey, int w, int h, ptrdiff_t stride, int color, int tail, int direction) | |
| 173 | 173 | { |
| 174 | 174 | int dx,dy; |
| 175 | 175 | |
| @@ -206,7 +206,7 @@ static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, · 30 unmodified lines | ||
| 206 | 206 | draw_line(buf, sx, sy, ex, ey, w, h, stride, color); |
| 207 | 207 | } |
| 208 | 208 | |
| 209 | −static void draw_block_rectangle(uint8_t *buf, int sx, int sy, int w, int h, int stride, int color) | |
| 209 | +static void draw_block_rectangle(uint8_t *buf, int sx, int sy, int w, int h, ptrdiff_t stride, int color) | |
| 210 | 210 | { |
| 211 | 211 | for (int x = sx; x < sx + w; x++) |
| 212 | 212 | buf[x] = color; |
| @@ -244,8 +244,8 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame) · 31 unmodified lines | ||
| 244 | 244 | const int h = AV_CEIL_RSHIFT(frame->height, s->vsub); |
| 245 | 245 | uint8_t *pu = frame->data[1]; |
| 246 | 246 | uint8_t *pv = frame->data[2]; |
| 247 | − const int lzu = frame->linesize[1]; | |
| 248 | − const int lzv = frame->linesize[2]; | |
| 247 | + const ptrdiff_t lzu = frame->linesize[1]; | |
| 248 | + const ptrdiff_t lzv = frame->linesize[2]; | |
| 249 | 249 | |
| 250 | 250 | for (y = 0; y < h; y++) { |
| 251 | 251 | for (x = 0; x < w; x++) { |
| @@ -263,7 +263,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame) · 11 unmodified lines | ||
| 263 | 263 | AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_VIDEO_ENC_PARAMS); |
| 264 | 264 | if (sd) { |
| 265 | 265 | AVVideoEncParams *par = (AVVideoEncParams*)sd->data; |
| 266 | − const int stride = frame->linesize[0]; | |
| 266 | + const ptrdiff_t stride = frame->linesize[0]; | |
| 267 | 267 | |
| 268 | 268 | if (par->nb_blocks) { |
| 269 | 269 | for (int block_idx = 0; block_idx < par->nb_blocks; block_idx++) { |
| @@ -96,9 +96,9 @@ static int colorcontrast_slice8(AVFilterContext *ctx, void *arg, int jobnr, int · 95 unmodified lines | ||
| 96 | 96 | const int height = frame->height; |
| 97 | 97 | const int slice_start = (height * jobnr) / nb_jobs; |
| 98 | 98 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 99 | − const int glinesize = frame->linesize[0]; | |
| 100 | − const int blinesize = frame->linesize[1]; | |
| 101 | − const int rlinesize = frame->linesize[2]; | |
| 99 | + const ptrdiff_t glinesize = frame->linesize[0]; | |
| 100 | + const ptrdiff_t blinesize = frame->linesize[1]; | |
| 101 | + const ptrdiff_t rlinesize = frame->linesize[2]; | |
| 102 | 102 | uint8_t *gptr = frame->data[0] + slice_start * glinesize; |
| 103 | 103 | uint8_t *bptr = frame->data[1] + slice_start * blinesize; |
| 104 | 104 | uint8_t *rptr = frame->data[2] + slice_start * rlinesize; |
| @@ -150,9 +150,9 @@ static int colorcontrast_slice16(AVFilterContext *ctx, void *arg, int jobnr, int · 45 unmodified lines | ||
| 150 | 150 | const int height = frame->height; |
| 151 | 151 | const int slice_start = (height * jobnr) / nb_jobs; |
| 152 | 152 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 153 | − const int glinesize = frame->linesize[0] / 2; | |
| 154 | − const int blinesize = frame->linesize[1] / 2; | |
| 155 | − const int rlinesize = frame->linesize[2] / 2; | |
| 153 | + const ptrdiff_t glinesize = frame->linesize[0] / 2; | |
| 154 | + const ptrdiff_t blinesize = frame->linesize[1] / 2; | |
| 155 | + const ptrdiff_t rlinesize = frame->linesize[2] / 2; | |
| 156 | 156 | uint16_t *gptr = (uint16_t *)frame->data[0] + slice_start * glinesize; |
| 157 | 157 | uint16_t *bptr = (uint16_t *)frame->data[1] + slice_start * blinesize; |
| 158 | 158 | uint16_t *rptr = (uint16_t *)frame->data[2] + slice_start * rlinesize; |
| @@ -203,7 +203,7 @@ static int colorcontrast_slice8p(AVFilterContext *ctx, void *arg, int jobnr, int · 44 unmodified lines | ||
| 203 | 203 | const int height = frame->height; |
| 204 | 204 | const int slice_start = (height * jobnr) / nb_jobs; |
| 205 | 205 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 206 | − const int linesize = frame->linesize[0]; | |
| 206 | + const ptrdiff_t linesize = frame->linesize[0]; | |
| 207 | 207 | const uint8_t roffset = s->rgba_map[R]; |
| 208 | 208 | const uint8_t goffset = s->rgba_map[G]; |
| 209 | 209 | const uint8_t boffset = s->rgba_map[B]; |
| @@ -255,7 +255,7 @@ static int colorcontrast_slice16p(AVFilterContext *ctx, void *arg, int jobnr, in · 45 unmodified lines | ||
| 255 | 255 | const int height = frame->height; |
| 256 | 256 | const int slice_start = (height * jobnr) / nb_jobs; |
| 257 | 257 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 258 | − const int linesize = frame->linesize[0] / 2; | |
| 258 | + const ptrdiff_t linesize = frame->linesize[0] / 2; | |
| 259 | 259 | const uint8_t roffset = s->rgba_map[R]; |
| 260 | 260 | const uint8_t goffset = s->rgba_map[G]; |
| 261 | 261 | const uint8_t boffset = s->rgba_map[B]; |
| @@ -69,8 +69,8 @@ static int average_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_job · 68 unmodified lines | ||
| 69 | 69 | const int height = s->planeheight[1]; |
| 70 | 70 | const int slice_start = (height * jobnr) / nb_jobs; |
| 71 | 71 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 72 | − const int ulinesize = frame->linesize[1]; | |
| 73 | − const int vlinesize = frame->linesize[2]; | |
| 72 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 73 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 74 | 74 | const uint8_t *uptr = (const uint8_t *)frame->data[1] + slice_start * ulinesize; |
| 75 | 75 | const uint8_t *vptr = (const uint8_t *)frame->data[2] + slice_start * vlinesize; |
| 76 | 76 | int sum_u = 0, sum_v = 0; |
| @@ -100,8 +100,8 @@ static int average_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jo · 23 unmodified lines | ||
| 100 | 100 | const int height = s->planeheight[1]; |
| 101 | 101 | const int slice_start = (height * jobnr) / nb_jobs; |
| 102 | 102 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 103 | − const int ulinesize = frame->linesize[1] / 2; | |
| 104 | − const int vlinesize = frame->linesize[2] / 2; | |
| 103 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 104 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 105 | 105 | const uint16_t *uptr = (const uint16_t *)frame->data[1] + slice_start * ulinesize; |
| 106 | 106 | const uint16_t *vptr = (const uint16_t *)frame->data[2] + slice_start * vlinesize; |
| 107 | 107 | int64_t sum_u = 0, sum_v = 0; |
| @@ -131,8 +131,8 @@ static int minmax_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs · 23 unmodified lines | ||
| 131 | 131 | const int height = s->planeheight[1]; |
| 132 | 132 | const int slice_start = (height * jobnr) / nb_jobs; |
| 133 | 133 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 134 | − const int ulinesize = frame->linesize[1]; | |
| 135 | − const int vlinesize = frame->linesize[2]; | |
| 134 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 135 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 136 | 136 | const uint8_t *uptr = (const uint8_t *)frame->data[1] + slice_start * ulinesize; |
| 137 | 137 | const uint8_t *vptr = (const uint8_t *)frame->data[2] + slice_start * vlinesize; |
| 138 | 138 | int min_u = 255, min_v = 255; |
| @@ -167,8 +167,8 @@ static int minmax_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_job · 28 unmodified lines | ||
| 167 | 167 | const int height = s->planeheight[1]; |
| 168 | 168 | const int slice_start = (height * jobnr) / nb_jobs; |
| 169 | 169 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 170 | − const int ulinesize = frame->linesize[1] / 2; | |
| 171 | − const int vlinesize = frame->linesize[2] / 2; | |
| 170 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 171 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 172 | 172 | const uint16_t *uptr = (const uint16_t *)frame->data[1] + slice_start * ulinesize; |
| 173 | 173 | const uint16_t *vptr = (const uint16_t *)frame->data[2] + slice_start * vlinesize; |
| 174 | 174 | int min_u = INT_MAX, min_v = INT_MAX; |
| @@ -201,8 +201,8 @@ static int median_8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) · 26 unmodified lines | ||
| 201 | 201 | const float imax = s->imax; |
| 202 | 202 | const int width = s->planewidth[1]; |
| 203 | 203 | const int height = s->planeheight[1]; |
| 204 | − const int ulinesize = frame->linesize[1]; | |
| 205 | − const int vlinesize = frame->linesize[2]; | |
| 204 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 205 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 206 | 206 | const uint8_t *uptr = (const uint8_t *)frame->data[1]; |
| 207 | 207 | const uint8_t *vptr = (const uint8_t *)frame->data[2]; |
| 208 | 208 | unsigned *uhistogram = s->uhistogram; |
| @@ -255,8 +255,8 @@ static int median_16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) · 46 unmodified lines | ||
| 255 | 255 | const float imax = s->imax; |
| 256 | 256 | const int width = s->planewidth[1]; |
| 257 | 257 | const int height = s->planeheight[1]; |
| 258 | − const int ulinesize = frame->linesize[1] / 2; | |
| 259 | − const int vlinesize = frame->linesize[2] / 2; | |
| 258 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 259 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 260 | 260 | const uint16_t *uptr = (const uint16_t *)frame->data[1]; |
| 261 | 261 | const uint16_t *vptr = (const uint16_t *)frame->data[2]; |
| 262 | 262 | unsigned *uhistogram = s->uhistogram; |
| @@ -323,9 +323,9 @@ static int colorcorrect_slice8(AVFilterContext *ctx, void *arg, int jobnr, int n · 60 unmodified lines | ||
| 323 | 323 | const int height = s->planeheight[1]; |
| 324 | 324 | const int slice_start = (height * jobnr) / nb_jobs; |
| 325 | 325 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 326 | − const int ylinesize = frame->linesize[0]; | |
| 327 | − const int ulinesize = frame->linesize[1]; | |
| 328 | − const int vlinesize = frame->linesize[2]; | |
| 326 | + const ptrdiff_t ylinesize = frame->linesize[0]; | |
| 327 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 328 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 329 | 329 | uint8_t *yptr = frame->data[0] + slice_start * chroma_h * ylinesize; |
| 330 | 330 | uint8_t *uptr = frame->data[1] + slice_start * ulinesize; |
| 331 | 331 | uint8_t *vptr = frame->data[2] + slice_start * vlinesize; |
| @@ -364,9 +364,9 @@ static int colorcorrect_slice16(AVFilterContext *ctx, void *arg, int jobnr, int · 32 unmodified lines | ||
| 364 | 364 | const int height = s->planeheight[1]; |
| 365 | 365 | const int slice_start = (height * jobnr) / nb_jobs; |
| 366 | 366 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 367 | − const int ylinesize = frame->linesize[0] / 2; | |
| 368 | − const int ulinesize = frame->linesize[1] / 2; | |
| 369 | − const int vlinesize = frame->linesize[2] / 2; | |
| 367 | + const ptrdiff_t ylinesize = frame->linesize[0] / 2; | |
| 368 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 369 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 370 | 370 | uint16_t *yptr = (uint16_t *)frame->data[0] + slice_start * chroma_h * ylinesize; |
| 371 | 371 | uint16_t *uptr = (uint16_t *)frame->data[1] + slice_start * ulinesize; |
| 372 | 372 | uint16_t *vptr = (uint16_t *)frame->data[2] + slice_start * vlinesize; |
| @@ -52,7 +52,7 @@ static int colorizey_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_j · 51 unmodified lines | ||
| 52 | 52 | const int height = s->planeheight[0]; |
| 53 | 53 | const int slice_start = (height * jobnr) / nb_jobs; |
| 54 | 54 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 55 | − const int ylinesize = frame->linesize[0]; | |
| 55 | + const ptrdiff_t ylinesize = frame->linesize[0]; | |
| 56 | 56 | uint8_t *yptr = frame->data[0] + slice_start * ylinesize; |
| 57 | 57 | const int yv = s->c[0]; |
| 58 | 58 | const float mix = s->mix; |
| @@ -75,7 +75,7 @@ static int colorizey_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_ · 16 unmodified lines | ||
| 75 | 75 | const int height = s->planeheight[0]; |
| 76 | 76 | const int slice_start = (height * jobnr) / nb_jobs; |
| 77 | 77 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 78 | − const int ylinesize = frame->linesize[0] / 2; | |
| 78 | + const ptrdiff_t ylinesize = frame->linesize[0] / 2; | |
| 79 | 79 | uint16_t *yptr = (uint16_t *)frame->data[0] + slice_start * ylinesize; |
| 80 | 80 | const int yv = s->c[0]; |
| 81 | 81 | const float mix = s->mix; |
| @@ -98,8 +98,8 @@ static int colorize_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jo · 16 unmodified lines | ||
| 98 | 98 | const int height = s->planeheight[1]; |
| 99 | 99 | const int slice_start = (height * jobnr) / nb_jobs; |
| 100 | 100 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 101 | − const int ulinesize = frame->linesize[1]; | |
| 102 | − const int vlinesize = frame->linesize[2]; | |
| 101 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 102 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 103 | 103 | uint8_t *uptr = frame->data[1] + slice_start * ulinesize; |
| 104 | 104 | uint8_t *vptr = frame->data[2] + slice_start * vlinesize; |
| 105 | 105 | const int u = s->c[1]; |
| @@ -126,8 +126,8 @@ static int colorize_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_j · 20 unmodified lines | ||
| 126 | 126 | const int height = s->planeheight[1]; |
| 127 | 127 | const int slice_start = (height * jobnr) / nb_jobs; |
| 128 | 128 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 129 | − const int ulinesize = frame->linesize[1] / 2; | |
| 130 | − const int vlinesize = frame->linesize[2] / 2; | |
| 129 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 130 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 131 | 131 | uint16_t *uptr = (uint16_t *)frame->data[1] + slice_start * ulinesize; |
| 132 | 132 | uint16_t *vptr = (uint16_t *)frame->data[2] + slice_start * vlinesize; |
| 133 | 133 | const int u = s->c[1]; |
| @@ -111,9 +111,9 @@ static int temperature_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb · 110 unmodified lines | ||
| 111 | 111 | const float *color = s->color; |
| 112 | 112 | const int slice_start = (height * jobnr) / nb_jobs; |
| 113 | 113 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 114 | − const int glinesize = frame->linesize[0]; | |
| 115 | − const int blinesize = frame->linesize[1]; | |
| 116 | − const int rlinesize = frame->linesize[2]; | |
| 114 | + const ptrdiff_t glinesize = frame->linesize[0]; | |
| 115 | + const ptrdiff_t blinesize = frame->linesize[1]; | |
| 116 | + const ptrdiff_t rlinesize = frame->linesize[2]; | |
| 117 | 117 | uint8_t *gptr = frame->data[0] + slice_start * glinesize; |
| 118 | 118 | uint8_t *bptr = frame->data[1] + slice_start * blinesize; |
| 119 | 119 | uint8_t *rptr = frame->data[2] + slice_start * rlinesize; |
| @@ -153,9 +153,9 @@ static int temperature_slice16(AVFilterContext *ctx, void *arg, int jobnr, int n · 33 unmodified lines | ||
| 153 | 153 | const float *color = s->color; |
| 154 | 154 | const int slice_start = (height * jobnr) / nb_jobs; |
| 155 | 155 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 156 | − const int glinesize = frame->linesize[0] / sizeof(uint16_t); | |
| 157 | − const int blinesize = frame->linesize[1] / sizeof(uint16_t); | |
| 158 | − const int rlinesize = frame->linesize[2] / sizeof(uint16_t); | |
| 156 | + const ptrdiff_t glinesize = frame->linesize[0] / sizeof(uint16_t); | |
| 157 | + const ptrdiff_t blinesize = frame->linesize[1] / sizeof(uint16_t); | |
| 158 | + const ptrdiff_t rlinesize = frame->linesize[2] / sizeof(uint16_t); | |
| 159 | 159 | uint16_t *gptr = (uint16_t *)frame->data[0] + slice_start * glinesize; |
| 160 | 160 | uint16_t *bptr = (uint16_t *)frame->data[1] + slice_start * blinesize; |
| 161 | 161 | uint16_t *rptr = (uint16_t *)frame->data[2] + slice_start * rlinesize; |
| @@ -198,7 +198,7 @@ static int temperature_slice8p(AVFilterContext *ctx, void *arg, int jobnr, int n · 36 unmodified lines | ||
| 198 | 198 | const uint8_t boffset = s->rgba_map[B]; |
| 199 | 199 | const int slice_start = (height * jobnr) / nb_jobs; |
| 200 | 200 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 201 | − const int linesize = frame->linesize[0]; | |
| 201 | + const ptrdiff_t linesize = frame->linesize[0]; | |
| 202 | 202 | uint8_t *ptr = frame->data[0] + slice_start * linesize; |
| 203 | 203 | |
| 204 | 204 | for (int y = slice_start; y < slice_end; y++) { |
| @@ -238,7 +238,7 @@ static int temperature_slice16p(AVFilterContext *ctx, void *arg, int jobnr, int · 33 unmodified lines | ||
| 238 | 238 | const uint8_t boffset = s->rgba_map[B]; |
| 239 | 239 | const int slice_start = (height * jobnr) / nb_jobs; |
| 240 | 240 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 241 | − const int linesize = frame->linesize[0] / sizeof(uint16_t); | |
| 241 | + const ptrdiff_t linesize = frame->linesize[0] / sizeof(uint16_t); | |
| 242 | 242 | uint16_t *ptr = (uint16_t *)frame->data[0] + slice_start * linesize; |
| 243 | 243 | |
| 244 | 244 | for (int y = slice_start; y < slice_end; y++) { |
| @@ -82,7 +82,7 @@ static void smear_borders8(FillBordersContext *s, AVFrame *frame) · 81 unmodified lines | ||
| 82 | 82 | |
| 83 | 83 | for (p = 0; p < s->nb_planes; p++) { |
| 84 | 84 | uint8_t *ptr = frame->data[p]; |
| 85 | − int linesize = frame->linesize[p]; | |
| 85 | + ptrdiff_t linesize = frame->linesize[p]; | |
| 86 | 86 | |
| 87 | 87 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 88 | 88 | memset(ptr + y * linesize, |
| @@ -112,7 +112,7 @@ static void smear_borders16(FillBordersContext *s, AVFrame *frame) · 23 unmodified lines | ||
| 112 | 112 | |
| 113 | 113 | for (p = 0; p < s->nb_planes; p++) { |
| 114 | 114 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 115 | − int linesize = frame->linesize[p] / 2; | |
| 115 | + ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 116 | 116 | |
| 117 | 117 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 118 | 118 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -144,7 +144,7 @@ static void mirror_borders8(FillBordersContext *s, AVFrame *frame) · 25 unmodified lines | ||
| 144 | 144 | |
| 145 | 145 | for (p = 0; p < s->nb_planes; p++) { |
| 146 | 146 | uint8_t *ptr = frame->data[p]; |
| 147 | − int linesize = frame->linesize[p]; | |
| 147 | + ptrdiff_t linesize = frame->linesize[p]; | |
| 148 | 148 | |
| 149 | 149 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 150 | 150 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -177,7 +177,7 @@ static void mirror_borders16(FillBordersContext *s, AVFrame *frame) · 26 unmodified lines | ||
| 177 | 177 | |
| 178 | 178 | for (p = 0; p < s->nb_planes; p++) { |
| 179 | 179 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 180 | − int linesize = frame->linesize[p] / 2; | |
| 180 | + ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 181 | 181 | |
| 182 | 182 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 183 | 183 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -211,7 +211,7 @@ static void fixed_borders8(FillBordersContext *s, AVFrame *frame) · 27 unmodified lines | ||
| 211 | 211 | for (p = 0; p < s->nb_planes; p++) { |
| 212 | 212 | uint8_t *ptr = frame->data[p]; |
| 213 | 213 | uint8_t fill = s->fill[p]; |
| 214 | − int linesize = frame->linesize[p]; | |
| 214 | + ptrdiff_t linesize = frame->linesize[p]; | |
| 215 | 215 | |
| 216 | 216 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 217 | 217 | memset(ptr + y * linesize, fill, s->borders[p].left); |
| @@ -236,7 +236,7 @@ static void fixed_borders16(FillBordersContext *s, AVFrame *frame) · 18 unmodified lines | ||
| 236 | 236 | for (p = 0; p < s->nb_planes; p++) { |
| 237 | 237 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 238 | 238 | uint16_t fill = s->fill[p] << (s->depth - 8); |
| 239 | − int linesize = frame->linesize[p] / 2; | |
| 239 | + ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 240 | 240 | |
| 241 | 241 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 242 | 242 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -268,7 +268,7 @@ static void reflect_borders8(FillBordersContext *s, AVFrame *frame) · 25 unmodified lines | ||
| 268 | 268 | |
| 269 | 269 | for (p = 0; p < s->nb_planes; p++) { |
| 270 | 270 | uint8_t *ptr = frame->data[p]; |
| 271 | − int linesize = frame->linesize[p]; | |
| 271 | + ptrdiff_t linesize = frame->linesize[p]; | |
| 272 | 272 | |
| 273 | 273 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 274 | 274 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -301,7 +301,7 @@ static void reflect_borders16(FillBordersContext *s, AVFrame *frame) · 26 unmodified lines | ||
| 301 | 301 | |
| 302 | 302 | for (p = 0; p < s->nb_planes; p++) { |
| 303 | 303 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 304 | − int linesize = frame->linesize[p] / 2; | |
| 304 | + ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 305 | 305 | |
| 306 | 306 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 307 | 307 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -334,7 +334,7 @@ static void wrap_borders8(FillBordersContext *s, AVFrame *frame) · 26 unmodified lines | ||
| 334 | 334 | |
| 335 | 335 | for (p = 0; p < s->nb_planes; p++) { |
| 336 | 336 | uint8_t *ptr = frame->data[p]; |
| 337 | − int linesize = frame->linesize[p]; | |
| 337 | + ptrdiff_t linesize = frame->linesize[p]; | |
| 338 | 338 | |
| 339 | 339 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 340 | 340 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -367,7 +367,7 @@ static void wrap_borders16(FillBordersContext *s, AVFrame *frame) · 26 unmodified lines | ||
| 367 | 367 | |
| 368 | 368 | for (p = 0; p < s->nb_planes; p++) { |
| 369 | 369 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 370 | − int linesize = frame->linesize[p] / 2; | |
| 370 | + ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 371 | 371 | |
| 372 | 372 | for (y = s->borders[p].top; y < s->planeheight[p] - s->borders[p].bottom; y++) { |
| 373 | 373 | for (x = 0; x < s->borders[p].left; x++) { |
| @@ -411,7 +411,7 @@ static void fade_borders8(FillBordersContext *s, AVFrame *frame) · 37 unmodified lines | ||
| 411 | 411 | for (p = 0; p < s->nb_planes; p++) { |
| 412 | 412 | uint8_t *ptr = frame->data[p]; |
| 413 | 413 | const uint8_t fill = s->fill[p]; |
| 414 | − const int linesize = frame->linesize[p]; | |
| 414 | + const ptrdiff_t linesize = frame->linesize[p]; | |
| 415 | 415 | const int start_left = s->borders[p].left; |
| 416 | 416 | const int start_right = s->planewidth[p] - s->borders[p].right; |
| 417 | 417 | const int start_top = s->borders[p].top; |
| @@ -453,7 +453,7 @@ static void fade_borders16(FillBordersContext *s, AVFrame *frame) · 35 unmodified lines | ||
| 453 | 453 | for (p = 0; p < s->nb_planes; p++) { |
| 454 | 454 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 455 | 455 | const uint16_t fill = s->fill[p] << (depth - 8); |
| 456 | − const int linesize = frame->linesize[p] / 2; | |
| 456 | + const ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 457 | 457 | const int start_left = s->borders[p].left; |
| 458 | 458 | const int start_right = s->planewidth[p] - s->borders[p].right; |
| 459 | 459 | const int start_top = s->borders[p].top; |
| @@ -491,7 +491,7 @@ static void margins_borders8(FillBordersContext *s, AVFrame *frame) · 31 unmodified lines | ||
| 491 | 491 | { |
| 492 | 492 | for (int p = 0; p < s->nb_planes; p++) { |
| 493 | 493 | uint8_t *ptr = (uint8_t *)frame->data[p]; |
| 494 | − const int linesize = frame->linesize[p]; | |
| 494 | + const ptrdiff_t linesize = frame->linesize[p]; | |
| 495 | 495 | const int left = s->borders[p].left; |
| 496 | 496 | const int right = s->borders[p].right; |
| 497 | 497 | const int top = s->borders[p].top; |
| @@ -536,7 +536,7 @@ static void margins_borders16(FillBordersContext *s, AVFrame *frame) · 38 unmodified lines | ||
| 536 | 536 | { |
| 537 | 537 | for (int p = 0; p < s->nb_planes; p++) { |
| 538 | 538 | uint16_t *ptr = (uint16_t *)frame->data[p]; |
| 539 | − const int linesize = frame->linesize[p] / 2; | |
| 539 | + const ptrdiff_t linesize = frame->linesize[p] / 2; | |
| 540 | 540 | const int left = s->borders[p].left; |
| 541 | 541 | const int right = s->borders[p].right; |
| 542 | 542 | const int top = s->borders[p].top; |
| @@ -105,7 +105,7 @@ static int do_slice_##name##_##xall(AVFilterContext *ctx, \ · 104 unmodified lines | ||
| 105 | 105 | const int process_h = frame->height; \ |
| 106 | 106 | const int slice_start = (process_h * jobnr ) / nb_jobs; \ |
| 107 | 107 | const int slice_end = (process_h * (jobnr+1)) / nb_jobs; \ |
| 108 | − const int linesize = frame->linesize[0] / sizeof(type); \ | |
| 108 | + const ptrdiff_t linesize = frame->linesize[0] / sizeof(type); \ | |
| 109 | 109 | type *row = (type *)frame->data[0] + linesize * slice_start; \ |
| 110 | 110 | const uint8_t offset_r = s->rgba_map[R]; \ |
| 111 | 111 | const uint8_t offset_g = s->rgba_map[G]; \ |
| @@ -1321,7 +1321,7 @@ const AVFilter ff_vf_lut3d = { · 1320 unmodified lines | ||
| 1321 | 1321 | static void update_clut_packed(LUT3DContext *lut3d, const AVFrame *frame) |
| 1322 | 1322 | { |
| 1323 | 1323 | const uint8_t *data = frame->data[0]; |
| 1324 | − const int linesize = frame->linesize[0]; | |
| 1324 | + const ptrdiff_t linesize = frame->linesize[0]; | |
| 1325 | 1325 | const int w = lut3d->clut_width; |
| 1326 | 1326 | const int step = lut3d->clut_step; |
| 1327 | 1327 | const uint8_t *rgba_map = lut3d->clut_rgba_map; |
| @@ -1360,9 +1360,9 @@ static void update_clut_planar(LUT3DContext *lut3d, const AVFrame *frame) · 32 unmodified lines | ||
| 1360 | 1360 | const uint8_t *datag = frame->data[0]; |
| 1361 | 1361 | const uint8_t *datab = frame->data[1]; |
| 1362 | 1362 | const uint8_t *datar = frame->data[2]; |
| 1363 | − const int glinesize = frame->linesize[0]; | |
| 1364 | − const int blinesize = frame->linesize[1]; | |
| 1365 | − const int rlinesize = frame->linesize[2]; | |
| 1363 | + const ptrdiff_t glinesize = frame->linesize[0]; | |
| 1364 | + const ptrdiff_t blinesize = frame->linesize[1]; | |
| 1365 | + const ptrdiff_t rlinesize = frame->linesize[2]; | |
| 1366 | 1366 | const int w = lut3d->clut_width; |
| 1367 | 1367 | const int level = lut3d->lutsize; |
| 1368 | 1368 | const int level2 = lut3d->lutsize2; |
| @@ -1407,9 +1407,9 @@ static void update_clut_float(LUT3DContext *lut3d, const AVFrame *frame) · 38 unmodified lines | ||
| 1407 | 1407 | const uint8_t *datag = frame->data[0]; |
| 1408 | 1408 | const uint8_t *datab = frame->data[1]; |
| 1409 | 1409 | const uint8_t *datar = frame->data[2]; |
| 1410 | − const int glinesize = frame->linesize[0]; | |
| 1411 | − const int blinesize = frame->linesize[1]; | |
| 1412 | − const int rlinesize = frame->linesize[2]; | |
| 1410 | + const ptrdiff_t glinesize = frame->linesize[0]; | |
| 1411 | + const ptrdiff_t blinesize = frame->linesize[1]; | |
| 1412 | + const ptrdiff_t rlinesize = frame->linesize[2]; | |
| 1413 | 1413 | const int w = lut3d->clut_width; |
| 1414 | 1414 | const int level = lut3d->lutsize; |
| 1415 | 1415 | const int level2 = lut3d->lutsize2; |
| @@ -89,9 +89,9 @@ static int monochrome_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_ · 88 unmodified lines | ||
| 89 | 89 | const int height = frame->height; |
| 90 | 90 | const int slice_start = (height * jobnr) / nb_jobs; |
| 91 | 91 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 92 | − const int ylinesize = frame->linesize[0]; | |
| 93 | − const int ulinesize = frame->linesize[1]; | |
| 94 | − const int vlinesize = frame->linesize[2]; | |
| 92 | + const ptrdiff_t ylinesize = frame->linesize[0]; | |
| 93 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 94 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 95 | 95 | uint8_t *yptr = frame->data[0] + slice_start * ylinesize; |
| 96 | 96 | const float ihigh = 1.f - s->high; |
| 97 | 97 | const float size = 1.f / s->size; |
| @@ -128,9 +128,9 @@ static int monochrome_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb · 30 unmodified lines | ||
| 128 | 128 | const int height = frame->height; |
| 129 | 129 | const int slice_start = (height * jobnr) / nb_jobs; |
| 130 | 130 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 131 | − const int ylinesize = frame->linesize[0] / 2; | |
| 132 | − const int ulinesize = frame->linesize[1] / 2; | |
| 133 | − const int vlinesize = frame->linesize[2] / 2; | |
| 131 | + const ptrdiff_t ylinesize = frame->linesize[0] / 2; | |
| 132 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 133 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 134 | 134 | uint16_t *yptr = (uint16_t *)frame->data[0] + slice_start * ylinesize; |
| 135 | 135 | const float ihigh = 1.f - s->high; |
| 136 | 136 | const float size = 1.f / s->size; |
| @@ -166,8 +166,8 @@ static int clear_slice8(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) · 29 unmodified lines | ||
| 166 | 166 | const int height = AV_CEIL_RSHIFT(frame->height, subh); |
| 167 | 167 | const int slice_start = (height * jobnr) / nb_jobs; |
| 168 | 168 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 169 | − const int ulinesize = frame->linesize[1]; | |
| 170 | − const int vlinesize = frame->linesize[2]; | |
| 169 | + const ptrdiff_t ulinesize = frame->linesize[1]; | |
| 170 | + const ptrdiff_t vlinesize = frame->linesize[2]; | |
| 171 | 171 | |
| 172 | 172 | for (int y = slice_start; y < slice_end; y++) { |
| 173 | 173 | uint8_t *uptr = frame->data[1] + y * ulinesize; |
| @@ -192,8 +192,8 @@ static int clear_slice16(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs · 18 unmodified lines | ||
| 192 | 192 | const int height = AV_CEIL_RSHIFT(frame->height, subh); |
| 193 | 193 | const int slice_start = (height * jobnr) / nb_jobs; |
| 194 | 194 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 195 | − const int ulinesize = frame->linesize[1] / 2; | |
| 196 | − const int vlinesize = frame->linesize[2] / 2; | |
| 195 | + const ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 196 | + const ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 197 | 197 | |
| 198 | 198 | for (int y = slice_start; y < slice_end; y++) { |
| 199 | 199 | uint16_t *uptr = (uint16_t *)frame->data[1] + y * ulinesize; |
| @@ -845,7 +845,7 @@ static void load_palette(PaletteUseContext *s, const AVFrame *palette_frame) · 844 unmodified lines | ||
| 845 | 845 | { |
| 846 | 846 | int i, x, y; |
| 847 | 847 | const uint32_t *p = (const uint32_t *)palette_frame->data[0]; |
| 848 | − const int p_linesize = palette_frame->linesize[0] >> 2; | |
| 848 | + const ptrdiff_t p_linesize = palette_frame->linesize[0] >> 2; | |
| 849 | 849 | |
| 850 | 850 | s->transparency_index = -1; |
| 851 | 851 | |
| @@ -77,14 +77,14 @@ static int vibrance_slice8(AVFilterContext *avctx, void *arg, int jobnr, int nb_ · 76 unmodified lines | ||
| 77 | 77 | const float srintensity = alternate * FFSIGN(rintensity); |
| 78 | 78 | const int slice_start = (height * jobnr) / nb_jobs; |
| 79 | 79 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 80 | − const int glinesize = frame->linesize[0]; | |
| 81 | − const int blinesize = frame->linesize[1]; | |
| 82 | − const int rlinesize = frame->linesize[2]; | |
| 83 | − const int alinesize = frame->linesize[3]; | |
| 84 | − const int gslinesize = in->linesize[0]; | |
| 85 | − const int bslinesize = in->linesize[1]; | |
| 86 | − const int rslinesize = in->linesize[2]; | |
| 87 | − const int aslinesize = in->linesize[3]; | |
| 80 | + const ptrdiff_t glinesize = frame->linesize[0]; | |
| 81 | + const ptrdiff_t blinesize = frame->linesize[1]; | |
| 82 | + const ptrdiff_t rlinesize = frame->linesize[2]; | |
| 83 | + const ptrdiff_t alinesize = frame->linesize[3]; | |
| 84 | + const ptrdiff_t gslinesize = in->linesize[0]; | |
| 85 | + const ptrdiff_t bslinesize = in->linesize[1]; | |
| 86 | + const ptrdiff_t rslinesize = in->linesize[2]; | |
| 87 | + const ptrdiff_t aslinesize = in->linesize[3]; | |
| 88 | 88 | const uint8_t *gsrc = in->data[0] + slice_start * glinesize; |
| 89 | 89 | const uint8_t *bsrc = in->data[1] + slice_start * blinesize; |
| 90 | 90 | const uint8_t *rsrc = in->data[2] + slice_start * rlinesize; |
| @@ -154,14 +154,14 @@ static int vibrance_slice16(AVFilterContext *avctx, void *arg, int jobnr, int nb · 63 unmodified lines | ||
| 154 | 154 | const float srintensity = alternate * FFSIGN(rintensity); |
| 155 | 155 | const int slice_start = (height * jobnr) / nb_jobs; |
| 156 | 156 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 157 | − const int gslinesize = in->linesize[0] / 2; | |
| 158 | − const int bslinesize = in->linesize[1] / 2; | |
| 159 | − const int rslinesize = in->linesize[2] / 2; | |
| 160 | − const int aslinesize = in->linesize[3] / 2; | |
| 161 | − const int glinesize = frame->linesize[0] / 2; | |
| 162 | − const int blinesize = frame->linesize[1] / 2; | |
| 163 | − const int rlinesize = frame->linesize[2] / 2; | |
| 164 | − const int alinesize = frame->linesize[3] / 2; | |
| 157 | + const ptrdiff_t gslinesize = in->linesize[0] / 2; | |
| 158 | + const ptrdiff_t bslinesize = in->linesize[1] / 2; | |
| 159 | + const ptrdiff_t rslinesize = in->linesize[2] / 2; | |
| 160 | + const ptrdiff_t aslinesize = in->linesize[3] / 2; | |
| 161 | + const ptrdiff_t glinesize = frame->linesize[0] / 2; | |
| 162 | + const ptrdiff_t blinesize = frame->linesize[1] / 2; | |
| 163 | + const ptrdiff_t rlinesize = frame->linesize[2] / 2; | |
| 164 | + const ptrdiff_t alinesize = frame->linesize[3] / 2; | |
| 165 | 165 | const uint16_t *gsrc = (const uint16_t *)in->data[0] + slice_start * gslinesize; |
| 166 | 166 | const uint16_t *bsrc = (const uint16_t *)in->data[1] + slice_start * bslinesize; |
| 167 | 167 | const uint16_t *rsrc = (const uint16_t *)in->data[2] + slice_start * rslinesize; |
| @@ -234,8 +234,8 @@ static int vibrance_slice8p(AVFilterContext *avctx, void *arg, int jobnr, int nb · 66 unmodified lines | ||
| 234 | 234 | const float srintensity = alternate * FFSIGN(rintensity); |
| 235 | 235 | const int slice_start = (height * jobnr) / nb_jobs; |
| 236 | 236 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 237 | − const int linesize = frame->linesize[0]; | |
| 238 | − const int slinesize = in->linesize[0]; | |
| 237 | + const ptrdiff_t linesize = frame->linesize[0]; | |
| 238 | + const ptrdiff_t slinesize = in->linesize[0]; | |
| 239 | 239 | const uint8_t *src = in->data[0] + slice_start * slinesize; |
| 240 | 240 | uint8_t *ptr = frame->data[0] + slice_start * linesize; |
| 241 | 241 | |
| @@ -300,8 +300,8 @@ static int vibrance_slice16p(AVFilterContext *avctx, void *arg, int jobnr, int n · 58 unmodified lines | ||
| 300 | 300 | const float srintensity = alternate * FFSIGN(rintensity); |
| 301 | 301 | const int slice_start = (height * jobnr) / nb_jobs; |
| 302 | 302 | const int slice_end = (height * (jobnr + 1)) / nb_jobs; |
| 303 | − const int linesize = frame->linesize[0] / 2; | |
| 304 | − const int slinesize = in->linesize[0] / 2; | |
| 303 | + const ptrdiff_t linesize = frame->linesize[0] / 2; | |
| 304 | + const ptrdiff_t slinesize = in->linesize[0] / 2; | |
| 305 | 305 | const uint16_t *src = (const uint16_t *)in->data[0] + slice_start * slinesize; |
| 306 | 306 | uint16_t *ptr = (uint16_t *)frame->data[0] + slice_start * linesize; |
| 307 | 307 | |
| @@ -248,7 +248,7 @@ static int draw_gradients_slice(AVFilterContext *ctx, void *arg, int job, int nb · 247 unmodified lines | ||
| 248 | 248 | const int height = frame->height; |
| 249 | 249 | const int start = (height * job ) / nb_jobs; |
| 250 | 250 | const int end = (height * (job+1)) / nb_jobs; |
| 251 | − const int linesize = frame->linesize[0] / 4; | |
| 251 | + const ptrdiff_t linesize = frame->linesize[0] / 4; | |
| 252 | 252 | uint32_t *dst = (uint32_t *)frame->data[0] + start * linesize; |
| 253 | 253 | const int type = s->type; |
| 254 | 254 | |
| @@ -272,7 +272,7 @@ static int draw_gradients_slice16(AVFilterContext *ctx, void *arg, int job, int · 17 unmodified lines | ||
| 272 | 272 | const int height = frame->height; |
| 273 | 273 | const int start = (height * job ) / nb_jobs; |
| 274 | 274 | const int end = (height * (job+1)) / nb_jobs; |
| 275 | − const int linesize = frame->linesize[0] / 8; | |
| 275 | + const ptrdiff_t linesize = frame->linesize[0] / 8; | |
| 276 | 276 | uint64_t *dst = (uint64_t *)frame->data[0] + start * linesize; |
| 277 | 277 | const int type = s->type; |
| 278 | 278 | |
| @@ -296,10 +296,10 @@ static int draw_gradients_slice32_planar(AVFilterContext *ctx, void *arg, int jo · 17 unmodified lines | ||
| 296 | 296 | const int height = frame->height; |
| 297 | 297 | const int start = (height * job ) / nb_jobs; |
| 298 | 298 | const int end = (height * (job+1)) / nb_jobs; |
| 299 | − const int linesize_g = frame->linesize[0] / 4; | |
| 300 | − const int linesize_b = frame->linesize[1] / 4; | |
| 301 | − const int linesize_r = frame->linesize[2] / 4; | |
| 302 | − const int linesize_a = frame->linesize[3] / 4; | |
| 299 | + const ptrdiff_t linesize_g = frame->linesize[0] / 4; | |
| 300 | + const ptrdiff_t linesize_b = frame->linesize[1] / 4; | |
| 301 | + const ptrdiff_t linesize_r = frame->linesize[2] / 4; | |
| 302 | + const ptrdiff_t linesize_a = frame->linesize[3] / 4; | |
| 303 | 303 | float *dst_g = (float *)frame->data[0] + start * linesize_g; |
| 304 | 304 | float *dst_b = (float *)frame->data[1] + start * linesize_b; |
| 305 | 305 | float *dst_r = (float *)frame->data[2] + start * linesize_r; |
| @@ -328,7 +328,7 @@ static void haldclutsrc_fill_picture(AVFilterContext *ctx, AVFrame *frame) · 327 unmodified lines | ||
| 328 | 328 | const int w = frame->width; |
| 329 | 329 | const int h = frame->height; |
| 330 | 330 | uint8_t *data = frame->data[0]; |
| 331 | − const int linesize = frame->linesize[0]; | |
| 331 | + const ptrdiff_t linesize = frame->linesize[0]; | |
| 332 | 332 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); |
| 333 | 333 | const int depth = desc->comp[0].depth; |
| 334 | 334 | const int planar = desc->flags & AV_PIX_FMT_FLAG_PLANAR; |
| @@ -510,7 +510,7 @@ AVFILTER_DEFINE_CLASS(testsrc); · 175 unmodified lines | ||
| 510 | 510 | * @param w width of the rectangle to draw, expressed as a number of segment_width units |
| 511 | 511 | * @param h height of the rectangle to draw, expressed as a number of segment_width units |
| 512 | 512 | */ |
| 513 | −static void draw_rectangle(unsigned val, uint8_t *dst, int dst_linesize, int segment_width, | |
| 513 | +static void draw_rectangle(unsigned val, uint8_t *dst, ptrdiff_t dst_linesize, int segment_width, | |
| 514 | 514 | int x, int y, int w, int h) |
| 515 | 515 | { |
| 516 | 516 | int i; |
| @@ -525,7 +525,7 @@ static void draw_rectangle(unsigned val, uint8_t *dst, int dst_linesize, int seg · 8 unmodified lines | ||
| 525 | 525 | } |
| 526 | 526 | } |
| 527 | 527 | |
| 528 | −static void draw_digit(int digit, uint8_t *dst, int dst_linesize, | |
| 528 | +static void draw_digit(int digit, uint8_t *dst, ptrdiff_t dst_linesize, | |
| 529 | 529 | int segment_width) |
| 530 | 530 | { |
| 531 | 531 | #define TOP_HBAR 1 |
| @@ -1004,7 +1004,7 @@ static void rgbtest_put_pixel(uint8_t *dstp[4], int dst_linesizep[4], · 472 unmodified lines | ||
| 1004 | 1004 | uint8_t rgba_map[4]) |
| 1005 | 1005 | { |
| 1006 | 1006 | uint8_t *dst = dstp[0]; |
| 1007 | − int dst_linesize = dst_linesizep[0]; | |
| 1007 | + ptrdiff_t dst_linesize = dst_linesizep[0]; | |
| 1008 | 1008 | uint32_t v; |
| 1009 | 1009 | uint8_t *p; |
| 1010 | 1010 | uint16_t *p16; |
| @@ -1031,7 +1031,7 @@ static void rgbtest_put_pixel(uint8_t *dstp[4], int dst_linesizep[4], · 20 unmodified lines | ||
| 1031 | 1031 | AV_WL32(p, v); |
| 1032 | 1032 | break; |
| 1033 | 1033 | case AV_PIX_FMT_GBRP: |
| 1034 | − p = dstp[0] + x + y * dst_linesizep[0]; | |
| 1034 | + p = dstp[0] + x + y * dst_linesize; | |
| 1035 | 1035 | p[0] = g; |
| 1036 | 1036 | p = dstp[1] + x + y * dst_linesizep[1]; |
| 1037 | 1037 | p[0] = b; |
| @@ -1160,9 +1160,9 @@ static void yuvtest_fill_picture8(AVFilterContext *ctx, AVFrame *frame) · 122 unmodified lines | ||
| 1160 | 1160 | uint8_t *ydst = frame->data[0]; |
| 1161 | 1161 | uint8_t *udst = frame->data[1]; |
| 1162 | 1162 | uint8_t *vdst = frame->data[2]; |
| 1163 | − int ylinesize = frame->linesize[0]; | |
| 1164 | − int ulinesize = frame->linesize[1]; | |
| 1165 | − int vlinesize = frame->linesize[2]; | |
| 1163 | + ptrdiff_t ylinesize = frame->linesize[0]; | |
| 1164 | + ptrdiff_t ulinesize = frame->linesize[1]; | |
| 1165 | + ptrdiff_t vlinesize = frame->linesize[2]; | |
| 1166 | 1166 | |
| 1167 | 1167 | for (y = 0; y < h; y++) { |
| 1168 | 1168 | for (x = 0; x < w; x++) { |
| @@ -1217,9 +1217,9 @@ static void yuvtest_fill_picture16(AVFilterContext *ctx, AVFrame *frame) · 48 unmodified lines | ||
| 1217 | 1217 | uint16_t *ydst = (uint16_t *)frame->data[0]; |
| 1218 | 1218 | uint16_t *udst = (uint16_t *)frame->data[1]; |
| 1219 | 1219 | uint16_t *vdst = (uint16_t *)frame->data[2]; |
| 1220 | − int ylinesize = frame->linesize[0] / 2; | |
| 1221 | − int ulinesize = frame->linesize[1] / 2; | |
| 1222 | − int vlinesize = frame->linesize[2] / 2; | |
| 1220 | + ptrdiff_t ylinesize = frame->linesize[0] / 2; | |
| 1221 | + ptrdiff_t ulinesize = frame->linesize[1] / 2; | |
| 1222 | + ptrdiff_t vlinesize = frame->linesize[2] / 2; | |
| 1223 | 1223 | |
| 1224 | 1224 | for (y = 0; y < h; y++) { |
| 1225 | 1225 | for (x = 0; x < w; x++) { |
| @@ -1394,7 +1394,7 @@ static void draw_bar(TestSourceContext *test, const uint8_t color[4], · 168 unmodified lines | ||
| 1394 | 1394 | |
| 1395 | 1395 | for (plane = 0; frame->data[plane]; plane++) { |
| 1396 | 1396 | const int c = color[plane]; |
| 1397 | − const int linesize = frame->linesize[plane]; | |
| 1397 | + const ptrdiff_t linesize = frame->linesize[plane]; | |
| 1398 | 1398 | int i, px, py, pw, ph; |
| 1399 | 1399 | |
| 1400 | 1400 | if (plane == 1 || plane == 2) { |
| @@ -1702,9 +1702,9 @@ AVFILTER_DEFINE_CLASS_EXT(allyuv_allrgb, "allyuv/allrgb", · 301 unmodified lines | ||
| 1702 | 1702 | |
| 1703 | 1703 | static void allyuv_fill_picture(AVFilterContext *ctx, AVFrame *frame) |
| 1704 | 1704 | { |
| 1705 | − const int ys = frame->linesize[0]; | |
| 1706 | − const int us = frame->linesize[1]; | |
| 1707 | − const int vs = frame->linesize[2]; | |
| 1705 | + const ptrdiff_t ys = frame->linesize[0]; | |
| 1706 | + const ptrdiff_t us = frame->linesize[1]; | |
| 1707 | + const ptrdiff_t vs = frame->linesize[2]; | |
| 1708 | 1708 | int x, y, j; |
| 1709 | 1709 | |
| 1710 | 1710 | for (y = 0; y < 4096; y++) { |
| @@ -1763,7 +1763,7 @@ const AVFilter ff_vsrc_allyuv = { · 52 unmodified lines | ||
| 1763 | 1763 | static void allrgb_fill_picture(AVFilterContext *ctx, AVFrame *frame) |
| 1764 | 1764 | { |
| 1765 | 1765 | unsigned x, y; |
| 1766 | − const int linesize = frame->linesize[0]; | |
| 1766 | + const ptrdiff_t linesize = frame->linesize[0]; | |
| 1767 | 1767 | uint8_t *line = frame->data[0]; |
| 1768 | 1768 | |
| 1769 | 1769 | for (y = 0; y < 4096; y++) { |
| @@ -2102,9 +2102,9 @@ static int zoneplate_fill_slice_##name(AVFilterContext *ctx, \ · 332 unmodified lines | ||
| 2102 | 2102 | const int nkt2t = kt2 * t * t, nktt = kt * t; \ |
| 2103 | 2103 | const int start = (h * job ) / nb_jobs; \ |
| 2104 | 2104 | const int end = (h * (job+1)) / nb_jobs; \ |
| 2105 | − const int ylinesize = frame->linesize[0] / sizeof(type); \ | |
| 2106 | − const int ulinesize = frame->linesize[1] / sizeof(type); \ | |
| 2107 | − const int vlinesize = frame->linesize[2] / sizeof(type); \ | |
| 2105 | + const ptrdiff_t ylinesize = frame->linesize[0] / sizeof(type); \ | |
| 2106 | + const ptrdiff_t ulinesize = frame->linesize[1] / sizeof(type); \ | |
| 2107 | + const ptrdiff_t vlinesize = frame->linesize[2] / sizeof(type); \ | |
| 2108 | 2108 | const int xreset = -(w / 2) - test->xo; \ |
| 2109 | 2109 | const int yreset = -(h / 2) - test->yo + start; \ |
| 2110 | 2110 | const int kU = test->kU, kV = test->kV; \ |