virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

intrax8: Change type of array stride parameters to ptrdiff_t

Browse Source 
ptrdiff_t is the correct type for array strides and similar.

Also rename all such parameters to "stride" for consistency.
This commit is contained in:
Diego Biurrun 2016-09-08 15:08:03 +02:00
parent 92c5755a18
commit 3281d823cd
3 changed files with 46 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libavcodec/intrax8.c
View File

@ -548,7 +548,7 @@ static void x8_ac_compensation(IntraX8Context *const w, const int direction,
} }
static void dsp_x8_put_solidcolor(const uint8_t pix, uint8_t *dst, static void dsp_x8_put_solidcolor(const uint8_t pix, uint8_t *dst,
const int linesize) const ptrdiff_t linesize)
{ {
int k; int k;
for (k = 0; k < 8; k++) { for (k = 0; k < 8; k++) {
@ -700,7 +700,7 @@ block_placed:
if (w->loopfilter) { if (w->loopfilter) {
uint8_t *ptr = w->dest[chroma]; uint8_t *ptr = w->dest[chroma];
int linesize = w->frame->linesize[!!chroma]; ptrdiff_t linesize = w->frame->linesize[!!chroma];
if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4))) if (!((w->edges & 2) || (zeros_only && (w->orient | 4) == 4)))
w->dsp.h_loop_filter(ptr, linesize, w->quant); w->dsp.h_loop_filter(ptr, linesize, w->quant);
@ -716,8 +716,8 @@ static void x8_init_block_index(IntraX8Context *w, AVFrame *frame)
{ {
// not parent codec linesize as this would be wrong for field pics // not parent codec linesize as this would be wrong for field pics
// not that IntraX8 has interlacing support ;) // not that IntraX8 has interlacing support ;)
const int linesize = frame->linesize[0]; const ptrdiff_t linesize = frame->linesize[0];
const int uvlinesize = frame->linesize[1]; const ptrdiff_t uvlinesize = frame->linesize[1];
w->dest[0] = frame->data[0]; w->dest[0] = frame->data[0];
w->dest[1] = frame->data[1]; w->dest[1] = frame->data[1];

67
libavcodec/intrax8dsp.c
View File

@ -63,8 +63,8 @@
4 - mb_x>= (mb_width-1) last block in the row, interpolate area #5; 4 - mb_x>= (mb_width-1) last block in the row, interpolate area #5;
-*/ -*/
static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst, static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
int linesize, int *range, int *psum, ptrdiff_t stride, int *range,
int edges) int *psum, int edges)
{ {
uint8_t *ptr; uint8_t *ptr;
int sum; int sum;
@ -98,12 +98,12 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
max_pix = FFMAX(max_pix, c); max_pix = FFMAX(max_pix, c);
dst[area2 + i] = c; dst[area2 + i] = c;
ptr += linesize; ptr += stride;
} }
} }
if (!(edges & 2)) { // (mb_y != 0) // there is row above if (!(edges & 2)) { // (mb_y != 0) // there is row above
ptr = src - linesize; // top line ptr = src - stride; // top line
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
c = *(ptr + i); c = *(ptr + i);
sum += c; sum += c;
@ -117,7 +117,7 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
memcpy(dst + area4, ptr, 16); // both area4 and 5 memcpy(dst + area4, ptr, 16); // both area4 and 5
} }
// area6 always present in the above block // area6 always present in the above block
memcpy(dst + area6, ptr - linesize, 8); memcpy(dst + area6, ptr - stride, 8);
} }
// now calculate the stuff we need // now calculate the stuff we need
if (edges & 3) { // mb_x ==0 || mb_y == 0) { if (edges & 3) { // mb_x ==0 || mb_y == 0) {
@ -131,7 +131,7 @@ static void x8_setup_spatial_compensation(uint8_t *src, uint8_t *dst,
sum += avg * 9; sum += avg * 9;
} else { } else {
// the edge pixel, in the top line and left column // the edge pixel, in the top line and left column
uint8_t c = *(src - 1 - linesize); uint8_t c = *(src - 1 - stride);
dst[area3] = c; dst[area3] = c;
sum += c; sum += c;
// edge pixel is not part of min/max // edge pixel is not part of min/max
@ -160,7 +160,7 @@ static const uint16_t zero_prediction_weights[64 * 2] = {
317, 846, 366, 731, 458, 611, 499, 499, 317, 846, 366, 731, 458, 611, 499, 499,
}; };
static void spatial_compensation_0(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_0(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int i, j; int i, j;
int x, y; int x, y;
@ -208,55 +208,55 @@ static void spatial_compensation_0(uint8_t *src, uint8_t *dst, int linesize)
dst[x] = ((uint32_t) top_sum[0][x] * zero_prediction_weights[y * 16 + x * 2 + 0] + dst[x] = ((uint32_t) top_sum[0][x] * zero_prediction_weights[y * 16 + x * 2 + 0] +
(uint32_t) left_sum[0][y] * zero_prediction_weights[y * 16 + x * 2 + 1] + (uint32_t) left_sum[0][y] * zero_prediction_weights[y * 16 + x * 2 + 1] +
0x8000) >> 16; 0x8000) >> 16;
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_1(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_1(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = src[area4 + FFMIN(2 * y + x + 2, 15)]; dst[x] = src[area4 + FFMIN(2 * y + x + 2, 15)];
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_2(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_2(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = src[area4 + 1 + y + x]; dst[x] = src[area4 + 1 + y + x];
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_3(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_3(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = src[area4 + ((y + 1) >> 1) + x]; dst[x] = src[area4 + ((y + 1) >> 1) + x];
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_4(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_4(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = (src[area4 + x] + src[area6 + x] + 1) >> 1; dst[x] = (src[area4 + x] + src[area6 + x] + 1) >> 1;
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_5(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_5(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
@ -267,22 +267,22 @@ static void spatial_compensation_5(uint8_t *src, uint8_t *dst, int linesize)
else else
dst[x] = src[area4 + x - ((y + 1) >> 1)]; dst[x] = src[area4 + x - ((y + 1) >> 1)];
} }
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_6(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_6(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = src[area3 + x - y]; dst[x] = src[area3 + x - y];
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_7(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_7(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
@ -293,55 +293,56 @@ static void spatial_compensation_7(uint8_t *src, uint8_t *dst, int linesize)
else else
dst[x] = src[area2 + 8 - y + (x >> 1)]; dst[x] = src[area2 + 8 - y + (x >> 1)];
} }
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_8(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_8(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = (src[area1 + 7 - y] + src[area2 + 7 - y] + 1) >> 1; dst[x] = (src[area1 + 7 - y] + src[area2 + 7 - y] + 1) >> 1;
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_9(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_9(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = src[area2 + 6 - FFMIN(x + y, 6)]; dst[x] = src[area2 + 6 - FFMIN(x + y, 6)];
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_10(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_10(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = (src[area2 + 7 - y] * (8 - x) + src[area4 + x] * x + 4) >> 3; dst[x] = (src[area2 + 7 - y] * (8 - x) + src[area4 + x] * x + 4) >> 3;
dst += linesize; dst += stride;
} }
} }
static void spatial_compensation_11(uint8_t *src, uint8_t *dst, int linesize) static void spatial_compensation_11(uint8_t *src, uint8_t *dst, ptrdiff_t stride)
{ {
int x, y; int x, y;
for (y = 0; y < 8; y++) { for (y = 0; y < 8; y++) {
for (x = 0; x < 8; x++) for (x = 0; x < 8; x++)
dst[x] = (src[area2 + 7 - y] * y + src[area4 + x] * (8 - y) + 4) >> 3; dst[x] = (src[area2 + 7 - y] * y + src[area4 + x] * (8 - y) + 4) >> 3;
dst += linesize; dst += stride;
} }
} }
static void x8_loop_filter(uint8_t *ptr, const int a_stride, const int b_stride, int quant) static void x8_loop_filter(uint8_t *ptr, const ptrdiff_t a_stride,
const ptrdiff_t b_stride, int quant)
{ {
int i, t; int i, t;
int p0, p1, p2, p3, p4, p5, p6, p7, p8, p9; int p0, p1, p2, p3, p4, p5, p6, p7, p8, p9;
@ -434,12 +435,12 @@ static void x8_loop_filter(uint8_t *ptr, const int a_stride, const int b_stride,
} }
} }
static void x8_h_loop_filter(uint8_t *src, int stride, int qscale) static void x8_h_loop_filter(uint8_t *src, ptrdiff_t stride, int qscale)
{ {
x8_loop_filter(src, stride, 1, qscale); x8_loop_filter(src, stride, 1, qscale);
} }
static void x8_v_loop_filter(uint8_t *src, int stride, int qscale) static void x8_v_loop_filter(uint8_t *src, ptrdiff_t stride, int qscale)
{ {
x8_loop_filter(src, 1, stride, qscale); x8_loop_filter(src, 1, stride, qscale);
} }

13
libavcodec/intrax8dsp.h
View File

@ -19,15 +19,18 @@
#ifndef AVCODEC_INTRAX8DSP_H #ifndef AVCODEC_INTRAX8DSP_H
#define AVCODEC_INTRAX8DSP_H #define AVCODEC_INTRAX8DSP_H
#include <stddef.h>
#include <stdint.h> #include <stdint.h>
typedef struct IntraX8DSPContext { typedef struct IntraX8DSPContext {
void (*v_loop_filter)(uint8_t *src, int stride, int qscale); void (*v_loop_filter)(uint8_t *src, ptrdiff_t stride, int qscale);
void (*h_loop_filter)(uint8_t *src, int stride, int qscale); void (*h_loop_filter)(uint8_t *src, ptrdiff_t stride, int qscale);
void (*spatial_compensation[12])(uint8_t *src, uint8_t *dst, int linesize); void (*spatial_compensation[12])(uint8_t *src, uint8_t *dst,
void (*setup_spatial_compensation)(uint8_t *src, uint8_t *dst, int linesize, ptrdiff_t stride);
int *range, int *sum, int edges); void (*setup_spatial_compensation)(uint8_t *src, uint8_t *dst,
ptrdiff_t stride, int *range,
int *sum, int edges);
} IntraX8DSPContext; } IntraX8DSPContext;
void ff_intrax8dsp_init(IntraX8DSPContext *dsp); void ff_intrax8dsp_init(IntraX8DSPContext *dsp);