Revision a6ddf8bf
| libavcore/avcore.h | ||
|---|---|---|
| 27 | 27 |
#include <libavutil/avutil.h> |
| 28 | 28 |
|
| 29 | 29 |
#define LIBAVCORE_VERSION_MAJOR 0 |
| 30 |
#define LIBAVCORE_VERSION_MINOR 4
|
|
| 30 |
#define LIBAVCORE_VERSION_MINOR 5
|
|
| 31 | 31 |
#define LIBAVCORE_VERSION_MICRO 0 |
| 32 | 32 |
|
| 33 | 33 |
#define LIBAVCORE_VERSION_INT AV_VERSION_INT(LIBAVCORE_VERSION_MAJOR, \ |
| libavcore/imgutils.c | ||
|---|---|---|
| 29 | 29 |
const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; |
| 30 | 30 |
int max_step [4]; /* max pixel step for each plane */ |
| 31 | 31 |
int max_step_comp[4]; /* the component for each plane which has the max pixel step */ |
| 32 |
int s, i;
|
|
| 32 |
int s; |
|
| 33 | 33 |
|
| 34 | 34 |
if (desc->flags & PIX_FMT_BITSTREAM) |
| 35 | 35 |
return (width * (desc->comp[0].step_minus1+1) + 7) >> 3; |
| 36 | 36 |
|
| 37 |
memset(max_step , 0, sizeof(max_step )); |
|
| 38 |
memset(max_step_comp, 0, sizeof(max_step_comp)); |
|
| 39 |
for (i = 0; i < 4; i++) {
|
|
| 40 |
const AVComponentDescriptor *comp = &(desc->comp[i]); |
|
| 41 |
if ((comp->step_minus1+1) > max_step[comp->plane]) {
|
|
| 42 |
max_step [comp->plane] = comp->step_minus1+1; |
|
| 43 |
max_step_comp[comp->plane] = i; |
|
| 44 |
} |
|
| 45 |
} |
|
| 46 |
|
|
| 37 |
av_fill_image_max_pixstep(max_step, max_step_comp, desc); |
|
| 47 | 38 |
s = (max_step_comp[plane] == 1 || max_step_comp[plane] == 2) ? desc->log2_chroma_w : 0; |
| 48 | 39 |
return max_step[plane] * (((width + (1 << s) - 1)) >> s); |
| 49 | 40 |
} |
| ... | ... | |
| 65 | 56 |
return 0; |
| 66 | 57 |
} |
| 67 | 58 |
|
| 68 |
memset(max_step , 0, sizeof(max_step )); |
|
| 69 |
memset(max_step_comp, 0, sizeof(max_step_comp)); |
|
| 70 |
for (i = 0; i < 4; i++) {
|
|
| 71 |
const AVComponentDescriptor *comp = &(desc->comp[i]); |
|
| 72 |
if ((comp->step_minus1+1) > max_step[comp->plane]) {
|
|
| 73 |
max_step [comp->plane] = comp->step_minus1+1; |
|
| 74 |
max_step_comp[comp->plane] = i; |
|
| 75 |
} |
|
| 76 |
} |
|
| 77 |
|
|
| 59 |
av_fill_image_max_pixstep(max_step, max_step_comp, desc); |
|
| 78 | 60 |
for (i = 0; i < 4; i++) {
|
| 79 | 61 |
int s = (max_step_comp[i] == 1 || max_step_comp[i] == 2) ? desc->log2_chroma_w : 0; |
| 80 | 62 |
linesizes[i] = max_step[i] * (((width + (1 << s) - 1)) >> s); |
| libavcore/imgutils.h | ||
|---|---|---|
| 24 | 24 |
* misc image utilities |
| 25 | 25 |
*/ |
| 26 | 26 |
|
| 27 |
#include "libavutil/pixfmt.h"
|
|
| 27 |
#include "libavutil/pixdesc.h"
|
|
| 28 | 28 |
#include "avcore.h" |
| 29 | 29 |
|
| 30 | 30 |
/** |
| 31 |
* Compute the max pixel step for each plane of an image with a |
|
| 32 |
* format described by pixdesc |
|
| 33 |
* |
|
| 34 |
* The pixel step is the distance in bytes between the first byte of |
|
| 35 |
* the group of bytes which describe a pixel component and the first |
|
| 36 |
* byte of the successive group in the same plane for the same |
|
| 37 |
* component. |
|
| 38 |
* |
|
| 39 |
* @param max_pixstep an array which is filled with the max pixel step |
|
| 40 |
* for each plane. Since a plane may contain different pixel |
|
| 41 |
* components, the computed max_pixstep[plane] is relative to the |
|
| 42 |
* component in the plane with the max pixel step. |
|
| 43 |
* @param max_pixstep_comp an array which is filled with the component |
|
| 44 |
* for each plane which has the max pixel step. May be NULL. |
|
| 45 |
*/ |
|
| 46 |
static inline void av_fill_image_max_pixstep(int max_pixstep[4], int max_pixstep_comp[4], |
|
| 47 |
const AVPixFmtDescriptor *pixdesc) |
|
| 48 |
{
|
|
| 49 |
int i; |
|
| 50 |
memset(max_pixstep, 0, 4*sizeof(max_pixstep[0])); |
|
| 51 |
if (max_pixstep_comp) |
|
| 52 |
memset(max_pixstep_comp, 0, 4*sizeof(max_pixstep_comp[0])); |
|
| 53 |
|
|
| 54 |
for (i = 0; i < 4; i++) {
|
|
| 55 |
const AVComponentDescriptor *comp = &(pixdesc->comp[i]); |
|
| 56 |
if ((comp->step_minus1+1) > max_pixstep[comp->plane]) {
|
|
| 57 |
max_pixstep[comp->plane] = comp->step_minus1+1; |
|
| 58 |
if (max_pixstep_comp) |
|
| 59 |
max_pixstep_comp[comp->plane] = i; |
|
| 60 |
} |
|
| 61 |
} |
|
| 62 |
} |
|
| 63 |
|
|
| 64 |
/** |
|
| 31 | 65 |
* Compute the size of an image line with format pix_fmt and width |
| 32 | 66 |
* width for the plane plane. |
| 33 | 67 |
* |
| libavfilter/vf_crop.c | ||
|---|---|---|
| 24 | 24 |
*/ |
| 25 | 25 |
|
| 26 | 26 |
#include "avfilter.h" |
| 27 |
#include "libavutil/pixdesc.h"
|
|
| 27 |
#include "libavcore/imgutils.h"
|
|
| 28 | 28 |
|
| 29 | 29 |
typedef struct {
|
| 30 | 30 |
int x; ///< x offset of the non-cropped area with respect to the input area |
| ... | ... | |
| 83 | 83 |
AVFilterContext *ctx = link->dst; |
| 84 | 84 |
CropContext *crop = ctx->priv; |
| 85 | 85 |
const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[link->format]; |
| 86 |
int i; |
|
| 87 |
|
|
| 88 |
memset(crop->max_step, 0, sizeof(crop->max_step)); |
|
| 89 |
for (i = 0; i < 4; i++) {
|
|
| 90 |
const AVComponentDescriptor *comp = &(pix_desc->comp[i]); |
|
| 91 |
if ((comp->step_minus1+1) > crop->max_step[comp->plane]) |
|
| 92 |
crop->max_step[comp->plane] = comp->step_minus1+1; |
|
| 93 |
} |
|
| 94 | 86 |
|
| 87 |
av_fill_image_max_pixstep(crop->max_step, NULL, pix_desc); |
|
| 95 | 88 |
crop->hsub = av_pix_fmt_descriptors[link->format].log2_chroma_w; |
| 96 | 89 |
crop->vsub = av_pix_fmt_descriptors[link->format].log2_chroma_h; |
| 97 | 90 |
|
| libavfilter/vf_hflip.c | ||
|---|---|---|
| 27 | 27 |
#include "avfilter.h" |
| 28 | 28 |
#include "libavutil/pixdesc.h" |
| 29 | 29 |
#include "libavutil/intreadwrite.h" |
| 30 |
#include "libavcore/imgutils.h" |
|
| 30 | 31 |
|
| 31 | 32 |
typedef struct {
|
| 32 | 33 |
int max_step[4]; ///< max pixel step for each plane, expressed as a number of bytes |
| ... | ... | |
| 68 | 69 |
{
|
| 69 | 70 |
FlipContext *flip = inlink->dst->priv; |
| 70 | 71 |
const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[inlink->format]; |
| 71 |
int i; |
|
| 72 |
|
|
| 73 |
memset(flip->max_step, 0, sizeof(flip->max_step)); |
|
| 74 |
for (i = 0; i < 4; i++) {
|
|
| 75 |
const AVComponentDescriptor *comp = &(pix_desc->comp[i]); |
|
| 76 |
if ((comp->step_minus1+1) > flip->max_step[comp->plane]) |
|
| 77 |
flip->max_step[comp->plane] = comp->step_minus1+1; |
|
| 78 |
} |
|
| 79 | 72 |
|
| 73 |
av_fill_image_max_pixstep(flip->max_step, NULL, pix_desc); |
|
| 80 | 74 |
flip->hsub = av_pix_fmt_descriptors[inlink->format].log2_chroma_w; |
| 81 | 75 |
flip->vsub = av_pix_fmt_descriptors[inlink->format].log2_chroma_h; |
| 82 | 76 |
|
Also available in: Unified diff