generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

lavd/v4l2: Replace s1 with ctx for consistency.

Browse Source 
No functional change in the code.

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Giorgio Vazzana 2014-09-05 17:12:39 +02:00 committed by Michael Niedermayer
parent d247a40aad
commit 39750b7364
1 changed files with 57 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
libavdevice/v4l2.c
View File

@ -635,9 +635,9 @@ static void mmap_close(struct video_data *s)
av_free(s->buf_len);
}
static int v4l2_set_parameters(AVFormatContext *s1)
static int v4l2_set_parameters(AVFormatContext *ctx)
{
struct video_data *s = s1->priv_data;
struct video_data *s = ctx->priv_data;
struct v4l2_standard standard = { 0 };
struct v4l2_streamparm streamparm = { 0 };
struct v4l2_fract *tpf;
@ -646,7 +646,7 @@ static int v4l2_set_parameters(AVFormatContext *s1)
if (s->framerate &&
(ret = av_parse_video_rate(&framerate_q, s->framerate)) < 0) {
av_log(s1, AV_LOG_ERROR, "Could not parse framerate '%s'.\n",
av_log(ctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n",
s->framerate);
return ret;
}
@ -654,7 +654,7 @@ static int v4l2_set_parameters(AVFormatContext *s1)
if (s->standard) {
if (s->std_id) {
ret = 0;
av_log(s1, AV_LOG_DEBUG, "Setting standard: %s\n", s->standard);
av_log(ctx, AV_LOG_DEBUG, "Setting standard: %s\n", s->standard);
/* set tv standard */
for (i = 0; ; i++) {
standard.index = i;
@ -666,17 +666,17 @@ static int v4l2_set_parameters(AVFormatContext *s1)
break;
}
if (ret < 0) {
av_log(s1, AV_LOG_ERROR, "Unknown or unsupported standard '%s'\n", s->standard);
av_log(ctx, AV_LOG_ERROR, "Unknown or unsupported standard '%s'\n", s->standard);
return ret;
}
if (v4l2_ioctl(s->fd, VIDIOC_S_STD, &standard.id) < 0) {
ret = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_S_STD): %s\n", av_err2str(ret));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_STD): %s\n", av_err2str(ret));
return ret;
}
} else {
av_log(s1, AV_LOG_WARNING,
av_log(ctx, AV_LOG_WARNING,
"This device does not support any standard\n");
}
}
@ -696,11 +696,11 @@ static int v4l2_set_parameters(AVFormatContext *s1)
tpf = &streamparm.parm.capture.timeperframe;
break;
}
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));
return ret;
}
if (standard.id == s->std_id) {
av_log(s1, AV_LOG_DEBUG,
av_log(ctx, AV_LOG_DEBUG,
"Current standard: %s, id: %"PRIx64", frameperiod: %d/%d\n",
standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);
break;
@ -713,7 +713,7 @@ static int v4l2_set_parameters(AVFormatContext *s1)
streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (v4l2_ioctl(s->fd, VIDIOC_G_PARM, &streamparm) < 0) {
ret = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret));
return ret;
}
@ -721,41 +721,41 @@ static int v4l2_set_parameters(AVFormatContext *s1)
if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
tpf = &streamparm.parm.capture.timeperframe;
av_log(s1, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n",
av_log(ctx, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n",
framerate_q.den, framerate_q.num);
tpf->numerator = framerate_q.den;
tpf->denominator = framerate_q.num;
if (v4l2_ioctl(s->fd, VIDIOC_S_PARM, &streamparm) < 0) {
ret = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_S_PARM): %s\n", av_err2str(ret));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_PARM): %s\n", av_err2str(ret));
return ret;
}
if (framerate_q.num != tpf->denominator ||
framerate_q.den != tpf->numerator) {
av_log(s1, AV_LOG_INFO,
av_log(ctx, AV_LOG_INFO,
"The driver changed the time per frame from "
"%d/%d to %d/%d\n",
framerate_q.den, framerate_q.num,
tpf->numerator, tpf->denominator);
}
} else {
av_log(s1, AV_LOG_WARNING,
av_log(ctx, AV_LOG_WARNING,
"The driver does not allow to change time per frame\n");
}
}
if (tpf->denominator > 0 && tpf->numerator > 0) {
s1->streams[0]->avg_frame_rate.num = tpf->denominator;
s1->streams[0]->avg_frame_rate.den = tpf->numerator;
s1->streams[0]->r_frame_rate = s1->streams[0]->avg_frame_rate;
ctx->streams[0]->avg_frame_rate.num = tpf->denominator;
ctx->streams[0]->avg_frame_rate.den = tpf->numerator;
ctx->streams[0]->r_frame_rate = ctx->streams[0]->avg_frame_rate;
} else
av_log(s1, AV_LOG_WARNING, "Time per frame unknown\n");
av_log(ctx, AV_LOG_WARNING, "Time per frame unknown\n");
return 0;
}
static int device_try_init(AVFormatContext *s1,
static int device_try_init(AVFormatContext *ctx,
enum AVPixelFormat pix_fmt,
int *width,
int *height,
@ -764,10 +764,10 @@ static int device_try_init(AVFormatContext *s1,
{
int ret, i;
*desired_format = avpriv_fmt_ff2v4l(pix_fmt, s1->video_codec_id);
*desired_format = avpriv_fmt_ff2v4l(pix_fmt, ctx->video_codec_id);
if (*desired_format) {
ret = device_init(s1, width, height, *desired_format);
ret = device_init(ctx, width, height, *desired_format);
if (ret < 0) {
*desired_format = 0;
if (ret != AVERROR(EINVAL))
@ -777,14 +777,14 @@ static int device_try_init(AVFormatContext *s1,
if (!*desired_format) {
for (i = 0; avpriv_fmt_conversion_table[i].codec_id != AV_CODEC_ID_NONE; i++) {
if (s1->video_codec_id == AV_CODEC_ID_NONE ||
avpriv_fmt_conversion_table[i].codec_id == s1->video_codec_id) {
av_log(s1, AV_LOG_DEBUG, "Trying to set codec:%s pix_fmt:%s\n",
if (ctx->video_codec_id == AV_CODEC_ID_NONE ||
avpriv_fmt_conversion_table[i].codec_id == ctx->video_codec_id) {
av_log(ctx, AV_LOG_DEBUG, "Trying to set codec:%s pix_fmt:%s\n",
avcodec_get_name(avpriv_fmt_conversion_table[i].codec_id),
(char *)av_x_if_null(av_get_pix_fmt_name(avpriv_fmt_conversion_table[i].ff_fmt), "none"));
*desired_format = avpriv_fmt_conversion_table[i].v4l2_fmt;
ret = device_init(s1, width, height, *desired_format);
ret = device_init(ctx, width, height, *desired_format);
if (ret >= 0)
break;
else if (ret != AVERROR(EINVAL))
@ -794,9 +794,9 @@ static int device_try_init(AVFormatContext *s1,
}
if (*desired_format == 0) {
av_log(s1, AV_LOG_ERROR, "Cannot find a proper format for "
av_log(ctx, AV_LOG_ERROR, "Cannot find a proper format for "
"codec '%s' (id %d), pixel format '%s' (id %d)\n",
avcodec_get_name(s1->video_codec_id), s1->video_codec_id,
avcodec_get_name(ctx->video_codec_id), ctx->video_codec_id,
(char *)av_x_if_null(av_get_pix_fmt_name(pix_fmt), "none"), pix_fmt);
ret = AVERROR(EINVAL);
}
@ -807,9 +807,9 @@ static int device_try_init(AVFormatContext *s1,
return ret;
}
static int v4l2_read_header(AVFormatContext *s1)
static int v4l2_read_header(AVFormatContext *ctx)
{
struct video_data *s = s1->priv_data;
struct video_data *s = ctx->priv_data;
AVStream *st;
int res = 0;
uint32_t desired_format;
@ -817,7 +817,7 @@ static int v4l2_read_header(AVFormatContext *s1)
enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
struct v4l2_input input = { 0 };
st = avformat_new_stream(s1, NULL);
st = avformat_new_stream(ctx, NULL);
if (!st)
return AVERROR(ENOMEM);
@ -828,23 +828,23 @@ static int v4l2_read_header(AVFormatContext *s1)
v4l2_log_file = fopen("/dev/null", "w");
#endif
s->fd = device_open(s1);
s->fd = device_open(ctx);
if (s->fd < 0)
return s->fd;
if (s->channel != -1) {
/* set video input */
av_log(s1, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel);
av_log(ctx, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel);
if (v4l2_ioctl(s->fd, VIDIOC_S_INPUT, &s->channel) < 0) {
res = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res));
goto fail;
}
} else {
/* get current video input */
if (v4l2_ioctl(s->fd, VIDIOC_G_INPUT, &s->channel) < 0) {
res = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res));
goto fail;
}
}
@ -853,40 +853,40 @@ static int v4l2_read_header(AVFormatContext *s1)
input.index = s->channel;
if (v4l2_ioctl(s->fd, VIDIOC_ENUMINPUT, &input) < 0) {
res = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMINPUT): %s\n", av_err2str(res));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMINPUT): %s\n", av_err2str(res));
goto fail;
}
s->std_id = input.std;
av_log(s1, AV_LOG_DEBUG, "Current input_channel: %d, input_name: %s, input_std: %"PRIx64"\n",
av_log(ctx, AV_LOG_DEBUG, "Current input_channel: %d, input_name: %s, input_std: %"PRIx64"\n",
s->channel, input.name, (uint64_t)input.std);
if (s->list_format) {
list_formats(s1, s->fd, s->list_format);
list_formats(ctx, s->fd, s->list_format);
res = AVERROR_EXIT;
goto fail;
}
if (s->list_standard) {
list_standards(s1);
list_standards(ctx);
res = AVERROR_EXIT;
goto fail;
}
avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
if ((res = v4l2_set_parameters(s1)) < 0)
if ((res = v4l2_set_parameters(ctx)) < 0)
goto fail;
if (s->pixel_format) {
AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format);
if (codec)
s1->video_codec_id = codec->id;
ctx->video_codec_id = codec->id;
pix_fmt = av_get_pix_fmt(s->pixel_format);
if (pix_fmt == AV_PIX_FMT_NONE && !codec) {
av_log(s1, AV_LOG_ERROR, "No such input format: %s.\n",
av_log(ctx, AV_LOG_ERROR, "No such input format: %s.\n",
s->pixel_format);
res = AVERROR(EINVAL);
@ -897,21 +897,21 @@ static int v4l2_read_header(AVFormatContext *s1)
if (!s->width && !s->height) {
struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };
av_log(s1, AV_LOG_VERBOSE,
av_log(ctx, AV_LOG_VERBOSE,
"Querying the device for the current frame size\n");
if (v4l2_ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) {
res = AVERROR(errno);
av_log(s1, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n", av_err2str(res));
av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n", av_err2str(res));
goto fail;
}
s->width = fmt.fmt.pix.width;
s->height = fmt.fmt.pix.height;
av_log(s1, AV_LOG_VERBOSE,
av_log(ctx, AV_LOG_VERBOSE,
"Setting frame size to %dx%d\n", s->width, s->height);
}
res = device_try_init(s1, pix_fmt, &s->width, &s->height, &desired_format, &codec_id);
res = device_try_init(ctx, pix_fmt, &s->width, &s->height, &desired_format, &codec_id);
if (res < 0)
goto fail;
@ -919,10 +919,10 @@ static int v4l2_read_header(AVFormatContext *s1)
* until now. Set video_codec_id in the context, as codec_id will
* not be available outside this function
*/
if (codec_id != AV_CODEC_ID_NONE && s1->video_codec_id == AV_CODEC_ID_NONE)
s1->video_codec_id = codec_id;
if (codec_id != AV_CODEC_ID_NONE && ctx->video_codec_id == AV_CODEC_ID_NONE)
ctx->video_codec_id = codec_id;
if ((res = av_image_check_size(s->width, s->height, 0, s1)) < 0)
if ((res = av_image_check_size(s->width, s->height, 0, ctx)) < 0)
goto fail;
s->frame_format = desired_format;
@ -931,8 +931,8 @@ static int v4l2_read_header(AVFormatContext *s1)
s->frame_size =
avpicture_get_size(st->codec->pix_fmt, s->width, s->height);
if ((res = mmap_init(s1)) ||
(res = mmap_start(s1)) < 0)
if ((res = mmap_init(ctx)) ||
(res = mmap_start(ctx)) < 0)
goto fail;
s->top_field_first = first_field(s, s->fd);
@ -961,14 +961,14 @@ fail:
return res;
}
static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt)
static int v4l2_read_packet(AVFormatContext *ctx, AVPacket *pkt)
{
struct video_data *s = s1->priv_data;
AVFrame *frame = s1->streams[0]->codec->coded_frame;
struct video_data *s = ctx->priv_data;
AVFrame *frame = ctx->streams[0]->codec->coded_frame;
int res;
av_init_packet(pkt);
if ((res = mmap_read_frame(s1, pkt)) < 0) {
if ((res = mmap_read_frame(ctx, pkt)) < 0) {
return res;
}
@ -980,12 +980,12 @@ static int v4l2_read_packet(AVFormatContext *s1, AVPacket *pkt)
return pkt->size;
}
static int v4l2_read_close(AVFormatContext *s1)
static int v4l2_read_close(AVFormatContext *ctx)
{
struct video_data *s = s1->priv_data;
struct video_data *s = ctx->priv_data;
if (avpriv_atomic_int_get(&s->buffers_queued) != s->buffers)
av_log(s1, AV_LOG_WARNING, "Some buffers are still owned by the caller on "
av_log(ctx, AV_LOG_WARNING, "Some buffers are still owned by the caller on "
"close.\n");
mmap_close(s);