libdc1394.c 10.1 KB
Newer Older
1 2 3
/*
 * IIDC1394 grab interface (uses libdc1394 and libraw1394)
 * Copyright (c) 2004 Roman Shaposhnik
4
 * Copyright (c) 2008 Alessandro Sappia
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14 15 16 17 18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 22
 */

23 24
#include <dc1394/dc1394.h>

25
#include "libavutil/imgutils.h"
26 27 28 29 30 31 32 33 34 35
#include "libavutil/internal.h"
#include "libavutil/log.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/parseutils.h"
#include "libavutil/pixdesc.h"

#include "libavformat/avformat.h"
#include "libavformat/internal.h"

36
typedef struct dc1394_data {
37
    AVClass *class;
38 39 40
    dc1394_t *d;
    dc1394camera_t *camera;
    dc1394video_frame_t *frame;
41
    int current_frame;
42
    int  frame_rate;        /**< frames per 1000 seconds (fps * 1000) */
43
    char *video_size;       /**< String describing video size, set by a private option. */
44
    char *pixel_format;     /**< Set by a private option. */
45
    char *framerate;        /**< Set by a private option. */
46

47 48
    int size;
    int stream_index;
49 50
} dc1394_data;

51
static const struct dc1394_frame_format {
52 53
    int width;
    int height;
54
    enum AVPixelFormat pix_fmt;
55 56
    int frame_size_id;
} dc1394_frame_formats[] = {
57
    { 320, 240, AV_PIX_FMT_UYVY422,   DC1394_VIDEO_MODE_320x240_YUV422 },
58
    { 640, 480, AV_PIX_FMT_GRAY8,     DC1394_VIDEO_MODE_640x480_MONO8 },
59 60
    { 640, 480, AV_PIX_FMT_UYYVYY411, DC1394_VIDEO_MODE_640x480_YUV411 },
    { 640, 480, AV_PIX_FMT_UYVY422,   DC1394_VIDEO_MODE_640x480_YUV422 },
61
    { 0, 0, 0, 0 } /* gotta be the last one */
62 63
};

64
static const struct dc1394_frame_rate {
65 66 67
    int frame_rate;
    int frame_rate_id;
} dc1394_frame_rates[] = {
68 69 70 71 72 73
    {  1875, DC1394_FRAMERATE_1_875 },
    {  3750, DC1394_FRAMERATE_3_75  },
    {  7500, DC1394_FRAMERATE_7_5   },
    { 15000, DC1394_FRAMERATE_15    },
    { 30000, DC1394_FRAMERATE_30    },
    { 60000, DC1394_FRAMERATE_60    },
74 75
    {120000, DC1394_FRAMERATE_120   },
    {240000, DC1394_FRAMERATE_240    },
76
    { 0, 0 } /* gotta be the last one */
77 78
};

79 80
#define OFFSET(x) offsetof(dc1394_data, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
81
static const AVOption options[] = {
82 83 84
    { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = "qvga"}, 0, 0, DEC },
    { "pixel_format", "", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = "uyvy422"}, 0, 0, DEC },
    { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "ntsc"}, 0, 0, DEC },
85 86 87 88 89 90 91 92
    { NULL },
};

static const AVClass libdc1394_class = {
    .class_name = "libdc1394 indev",
    .item_name  = av_default_item_name,
    .option     = options,
    .version    = LIBAVUTIL_VERSION_INT,
93
    .category   = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,
94 95 96
};


97
static inline int dc1394_read_common(AVFormatContext *c,
98
                                     const struct dc1394_frame_format **select_fmt, const struct dc1394_frame_rate **select_fps)
99 100
{
    dc1394_data* dc1394 = c->priv_data;
101
    AVStream* vst;
102 103
    const struct dc1394_frame_format *fmt;
    const struct dc1394_frame_rate *fps;
104
    enum AVPixelFormat pix_fmt;
105
    int width, height;
106
    AVRational framerate;
107
    int ret = 0;
108

109
    if ((pix_fmt = av_get_pix_fmt(dc1394->pixel_format)) == AV_PIX_FMT_NONE) {
110 111
        av_log(c, AV_LOG_ERROR, "No such pixel format: %s.\n", dc1394->pixel_format);
        ret = AVERROR(EINVAL);
112 113 114
        goto out;
    }

115
    if ((ret = av_parse_video_size(&width, &height, dc1394->video_size)) < 0) {
116
        av_log(c, AV_LOG_ERROR, "Could not parse video size '%s'.\n", dc1394->video_size);
117
        goto out;
118
    }
119
    if ((ret = av_parse_video_rate(&framerate, dc1394->framerate)) < 0) {
120
        av_log(c, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", dc1394->framerate);
121
        goto out;
122
    }
123
    dc1394->frame_rate = av_rescale(1000, framerate.num, framerate.den);
124

125
    for (fmt = dc1394_frame_formats; fmt->width; fmt++)
126
         if (fmt->pix_fmt == pix_fmt && fmt->width == width && fmt->height == height)
127
             break;
128

129
    for (fps = dc1394_frame_rates; fps->frame_rate; fps++)
130
         if (fps->frame_rate == dc1394->frame_rate)
131
             break;
132

133
    if (!fps->frame_rate || !fmt->width) {
134
        av_log(c, AV_LOG_ERROR, "Can't find matching camera format for %s, %dx%d@%d:1000fps\n", av_get_pix_fmt_name(pix_fmt),
135
                                                                                                width, height, dc1394->frame_rate);
136
        ret = AVERROR(EINVAL);
137
        goto out;
138 139 140
    }

    /* create a video stream */
141
    vst = avformat_new_stream(c, NULL);
142 143
    if (!vst) {
        ret = AVERROR(ENOMEM);
144
        goto out;
145
    }
146
    avpriv_set_pts_info(vst, 64, 1, 1000);
147 148 149 150 151 152
    vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    vst->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
    vst->codecpar->width = fmt->width;
    vst->codecpar->height = fmt->height;
    vst->codecpar->format = fmt->pix_fmt;
    vst->avg_frame_rate = framerate;
153 154

    dc1394->current_frame = 0;
155 156 157
    dc1394->stream_index = vst->index;
    dc1394->size = av_image_get_buffer_size(fmt->pix_fmt,
                                            fmt->width, fmt->height, 1);
158

159 160
    vst->codecpar->bit_rate = av_rescale(dc1394->size * 8,
                                         fps->frame_rate, 1000);
161 162 163
    *select_fps = fps;
    *select_fmt = fmt;
out:
164
    return ret;
165 166
}

167
static int dc1394_read_header(AVFormatContext *c)
168 169 170 171
{
    dc1394_data* dc1394 = c->priv_data;
    dc1394camera_list_t *list;
    int res, i;
172 173
    const struct dc1394_frame_format *fmt = NULL;
    const struct dc1394_frame_rate *fps = NULL;
174

175
    if (dc1394_read_common(c, &fmt, &fps) != 0)
176 177
       return -1;

178
    /* Now let us prep the hardware. */
179
    dc1394->d = dc1394_new();
180 181 182 183 184 185 186 187
    if (dc1394_camera_enumerate(dc1394->d, &list) != DC1394_SUCCESS || !list) {
        av_log(c, AV_LOG_ERROR, "Unable to look for an IIDC camera.\n");
        goto out;
    }

    if (list->num == 0) {
        av_log(c, AV_LOG_ERROR, "No cameras found.\n");
        dc1394_camera_free_list(list);
188 189 190 191 192
        goto out;
    }

    /* FIXME: To select a specific camera I need to search in list its guid */
    dc1394->camera = dc1394_camera_new (dc1394->d, list->ids[0].guid);
193 194 195 196 197 198 199 200

    if (!dc1394->camera) {
         av_log(c, AV_LOG_ERROR, "Unable to open camera with guid 0x%"PRIx64"\n",
                list->ids[0].guid);
         dc1394_camera_free_list(list);
         goto out;
    }

201 202 203 204 205 206
    if (list->num > 1) {
        av_log(c, AV_LOG_INFO, "Working with the first camera found\n");
    }

    /* Freeing list of cameras */
    dc1394_camera_free_list (list);
207

208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
    /* Select MAX Speed possible from the cam */
    if (dc1394->camera->bmode_capable>0) {
       dc1394_video_set_operation_mode(dc1394->camera, DC1394_OPERATION_MODE_1394B);
       i = DC1394_ISO_SPEED_800;
    } else {
       i = DC1394_ISO_SPEED_400;
    }

    for (res = DC1394_FAILURE; i >= DC1394_ISO_SPEED_MIN && res != DC1394_SUCCESS; i--) {
            res=dc1394_video_set_iso_speed(dc1394->camera, i);
    }
    if (res != DC1394_SUCCESS) {
        av_log(c, AV_LOG_ERROR, "Couldn't set ISO Speed\n");
        goto out_camera;
    }

    if (dc1394_video_set_mode(dc1394->camera, fmt->frame_size_id) != DC1394_SUCCESS) {
        av_log(c, AV_LOG_ERROR, "Couldn't set video format\n");
        goto out_camera;
    }

    if (dc1394_video_set_framerate(dc1394->camera,fps->frame_rate_id) != DC1394_SUCCESS) {
        av_log(c, AV_LOG_ERROR, "Couldn't set framerate %d \n",fps->frame_rate);
        goto out_camera;
    }
    if (dc1394_capture_setup(dc1394->camera, 10, DC1394_CAPTURE_FLAGS_DEFAULT)!=DC1394_SUCCESS) {
        av_log(c, AV_LOG_ERROR, "Cannot setup camera \n");
        goto out_camera;
    }

    if (dc1394_video_set_transmission(dc1394->camera, DC1394_ON) !=DC1394_SUCCESS) {
        av_log(c, AV_LOG_ERROR, "Cannot start capture\n");
        goto out_camera;
    }
    return 0;

out_camera:
    dc1394_capture_stop(dc1394->camera);
    dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);
    dc1394_camera_free (dc1394->camera);
out:
    dc1394_free(dc1394->d);
    return -1;
}

253
static int dc1394_read_packet(AVFormatContext *c, AVPacket *pkt)
254 255 256 257 258 259 260 261 262 263 264 265
{
    struct dc1394_data *dc1394 = c->priv_data;
    int res;

    /* discard stale frame */
    if (dc1394->current_frame++) {
        if (dc1394_capture_enqueue(dc1394->camera, dc1394->frame) != DC1394_SUCCESS)
            av_log(c, AV_LOG_ERROR, "failed to release %d frame\n", dc1394->current_frame);
    }

    res = dc1394_capture_dequeue(dc1394->camera, DC1394_CAPTURE_POLICY_WAIT, &dc1394->frame);
    if (res == DC1394_SUCCESS) {
266 267 268 269 270
        pkt->data = (uint8_t *)dc1394->frame->image;
        pkt->size = dc1394->frame->image_bytes;
        pkt->pts = dc1394->current_frame * 1000000 / dc1394->frame_rate;
        pkt->flags |= AV_PKT_FLAG_KEY;
        pkt->stream_index = dc1394->stream_index;
271 272
    } else {
        av_log(c, AV_LOG_ERROR, "DMA capture failed\n");
273
        return AVERROR_INVALIDDATA;
274 275
    }

276
    return pkt->size;
277 278
}

279
static int dc1394_close(AVFormatContext * context)
280 281 282 283 284 285 286 287 288 289 290
{
    struct dc1394_data *dc1394 = context->priv_data;

    dc1394_video_set_transmission(dc1394->camera, DC1394_OFF);
    dc1394_capture_stop(dc1394->camera);
    dc1394_camera_free(dc1394->camera);
    dc1394_free(dc1394->d);

    return 0;
}

291
AVInputFormat ff_libdc1394_demuxer = {
292
    .name           = "libdc1394",
293
    .long_name      = NULL_IF_CONFIG_SMALL("dc1394 v.2 A/V grab"),
294
    .priv_data_size = sizeof(struct dc1394_data),
295 296 297
    .read_header    = dc1394_read_header,
    .read_packet    = dc1394_read_packet,
    .read_close     = dc1394_close,
298
    .flags          = AVFMT_NOFILE,
299
    .priv_class     = &libdc1394_class,
300
};