Statistics
| Branch: | Revision:

ffmpeg / libavformat / raw.c @ 25f8db58

History | View | Annotate | Download (18 KB)

1 de6d9b64 Fabrice Bellard
/* 
2
 * RAW encoder and decoder
3 19720f15 Fabrice Bellard
 * Copyright (c) 2001 Fabrice Bellard.
4 84c63c01 Alex Beregszaszi
 * Copyright (c) 2005 Alex Beregszaszi
5 de6d9b64 Fabrice Bellard
 *
6 19720f15 Fabrice Bellard
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10 de6d9b64 Fabrice Bellard
 *
11 19720f15 Fabrice Bellard
 * This library is distributed in the hope that it will be useful,
12 de6d9b64 Fabrice Bellard
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 19720f15 Fabrice Bellard
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15 de6d9b64 Fabrice Bellard
 *
16 19720f15 Fabrice Bellard
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 de6d9b64 Fabrice Bellard
 */
20
#include "avformat.h"
21
22 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
23 de6d9b64 Fabrice Bellard
/* simple formats */
24 5c91a675 Zdenek Kabelac
static int raw_write_header(struct AVFormatContext *s)
25 de6d9b64 Fabrice Bellard
{
26
    return 0;
27
}
28
29 e928649b Michael Niedermayer
static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
30 de6d9b64 Fabrice Bellard
{
31 e928649b Michael Niedermayer
    put_buffer(&s->pb, pkt->data, pkt->size);
32 de6d9b64 Fabrice Bellard
    put_flush_packet(&s->pb);
33
    return 0;
34
}
35
36 5c91a675 Zdenek Kabelac
static int raw_write_trailer(struct AVFormatContext *s)
37 de6d9b64 Fabrice Bellard
{
38
    return 0;
39
}
40 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
41 de6d9b64 Fabrice Bellard
42
/* raw input */
43 0c1a9eda Zdenek Kabelac
static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
44 de6d9b64 Fabrice Bellard
{
45
    AVStream *st;
46 c9a65ca8 Fabrice Bellard
    int id;
47 de6d9b64 Fabrice Bellard
48 c9a65ca8 Fabrice Bellard
    st = av_new_stream(s, 0);
49 de6d9b64 Fabrice Bellard
    if (!st)
50 c9a65ca8 Fabrice Bellard
        return AVERROR_NOMEM;
51 de6d9b64 Fabrice Bellard
    if (ap) {
52 c9a65ca8 Fabrice Bellard
        id = s->iformat->value;
53
        if (id == CODEC_ID_RAWVIDEO) {
54 01f4895c Michael Niedermayer
            st->codec->codec_type = CODEC_TYPE_VIDEO;
55 de6d9b64 Fabrice Bellard
        } else {
56 01f4895c Michael Niedermayer
            st->codec->codec_type = CODEC_TYPE_AUDIO;
57 de6d9b64 Fabrice Bellard
        }
58 01f4895c Michael Niedermayer
        st->codec->codec_id = id;
59 c9a65ca8 Fabrice Bellard
60 01f4895c Michael Niedermayer
        switch(st->codec->codec_type) {
61 de6d9b64 Fabrice Bellard
        case CODEC_TYPE_AUDIO:
62 01f4895c Michael Niedermayer
            st->codec->sample_rate = ap->sample_rate;
63
            st->codec->channels = ap->channels;
64
            av_set_pts_info(st, 64, 1, st->codec->sample_rate);
65 de6d9b64 Fabrice Bellard
            break;
66
        case CODEC_TYPE_VIDEO:
67 c0df9d75 Michael Niedermayer
            av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
68 01f4895c Michael Niedermayer
            st->codec->width = ap->width;
69
            st->codec->height = ap->height;
70
            st->codec->pix_fmt = ap->pix_fmt;
71
            if(st->codec->pix_fmt == PIX_FMT_NONE)
72
                st->codec->pix_fmt= PIX_FMT_YUV420P;
73 de6d9b64 Fabrice Bellard
            break;
74
        default:
75 27e084bd Fabrice Bellard
            return -1;
76 de6d9b64 Fabrice Bellard
        }
77
    } else {
78 27e084bd Fabrice Bellard
        return -1;
79 de6d9b64 Fabrice Bellard
    }
80
    return 0;
81
}
82
83 2e93e3aa Fabrice Bellard
#define RAW_PACKET_SIZE 1024
84 de6d9b64 Fabrice Bellard
85 5c91a675 Zdenek Kabelac
static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
86 de6d9b64 Fabrice Bellard
{
87 7866eeff Michael Niedermayer
    int ret, size;
88 2a6874fd Fabrice Bellard
    //    AVStream *st = s->streams[0];
89 7866eeff Michael Niedermayer
    
90 231dd3f3 Fabrice Bellard
    size= RAW_PACKET_SIZE;
91 de6d9b64 Fabrice Bellard
92 2692067a Michael Niedermayer
    ret= av_get_packet(&s->pb, pkt, size);
93 de6d9b64 Fabrice Bellard
94
    pkt->stream_index = 0;
95 2e93e3aa Fabrice Bellard
    if (ret <= 0) {
96 0bd586c5 Mike Melanson
        return AVERROR_IO;
97 2e93e3aa Fabrice Bellard
    }
98
    /* note: we need to modify the packet size here to handle the last
99
       packet */
100
    pkt->size = ret;
101 de6d9b64 Fabrice Bellard
    return ret;
102
}
103
104 e15dec10 Leon van Stuivenberg
static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
105
{
106
    int ret, size;
107
108
    size = RAW_PACKET_SIZE;
109
110
    if (av_new_packet(pkt, size) < 0)
111 0bd586c5 Mike Melanson
        return AVERROR_IO;
112 2692067a Michael Niedermayer
    
113
    pkt->pos= url_ftell(&s->pb);
114 e15dec10 Leon van Stuivenberg
    pkt->stream_index = 0;
115
    ret = get_partial_buffer(&s->pb, pkt->data, size);
116
    if (ret <= 0) {
117
        av_free_packet(pkt);
118 0bd586c5 Mike Melanson
        return AVERROR_IO;
119 e15dec10 Leon van Stuivenberg
    }
120
    pkt->size = ret;
121
    return ret;
122
}
123
124 84c63c01 Alex Beregszaszi
// http://www.artificis.hu/files/texts/ingenient.txt
125
static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
126
{
127
    int ret, size, w, h, unk1, unk2;
128
    
129
    if (get_le32(&s->pb) != MKTAG('M', 'J', 'P', 'G'))
130
        return AVERROR_IO; // FIXME
131
132
    size = get_le32(&s->pb);
133
    
134
    w = get_le16(&s->pb);
135
    h = get_le16(&s->pb);
136
    
137
    url_fskip(&s->pb, 8); // zero + size (padded?)
138
    url_fskip(&s->pb, 2);
139
    unk1 = get_le16(&s->pb);
140
    unk2 = get_le16(&s->pb);
141
    url_fskip(&s->pb, 22); // ascii timestamp
142
    
143
    av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
144
        size, w, h, unk1, unk2);
145
146
    if (av_new_packet(pkt, size) < 0)
147
        return AVERROR_IO;
148
149
    pkt->pos = url_ftell(&s->pb);
150
    pkt->stream_index = 0;
151
    ret = get_buffer(&s->pb, pkt->data, size);
152
    if (ret <= 0) {
153
        av_free_packet(pkt);
154
        return AVERROR_IO;
155
    }
156
    pkt->size = ret;
157
    return ret;
158
}
159
160 5c91a675 Zdenek Kabelac
static int raw_read_close(AVFormatContext *s)
161 de6d9b64 Fabrice Bellard
{
162
    return 0;
163
}
164
165 4986a429 Fabrice Bellard
int pcm_read_seek(AVFormatContext *s, 
166 7b3c1382 Michael Niedermayer
                  int stream_index, int64_t timestamp, int flags)
167 4986a429 Fabrice Bellard
{
168
    AVStream *st;
169
    int block_align, byte_rate;
170
    int64_t pos;
171
172
    st = s->streams[0];
173 01f4895c Michael Niedermayer
    switch(st->codec->codec_id) {
174 4986a429 Fabrice Bellard
    case CODEC_ID_PCM_S16LE:
175
    case CODEC_ID_PCM_S16BE:
176
    case CODEC_ID_PCM_U16LE:
177
    case CODEC_ID_PCM_U16BE:
178 01f4895c Michael Niedermayer
        block_align = 2 * st->codec->channels;
179
        byte_rate = block_align * st->codec->sample_rate;
180 4986a429 Fabrice Bellard
        break;
181
    case CODEC_ID_PCM_S8:
182
    case CODEC_ID_PCM_U8:
183
    case CODEC_ID_PCM_MULAW:
184
    case CODEC_ID_PCM_ALAW:
185 01f4895c Michael Niedermayer
        block_align = st->codec->channels;
186
        byte_rate = block_align * st->codec->sample_rate;
187 4986a429 Fabrice Bellard
        break;
188
    default:
189 01f4895c Michael Niedermayer
        block_align = st->codec->block_align;
190
        byte_rate = st->codec->bit_rate / 8;
191 4986a429 Fabrice Bellard
        break;
192
    }
193
    
194
    if (block_align <= 0 || byte_rate <= 0)
195
        return -1;
196
197
    /* compute the position by aligning it to block_align */
198 7b3c1382 Michael Niedermayer
    pos = av_rescale_rnd(timestamp * byte_rate, 
199
                         st->time_base.num, 
200
                         st->time_base.den * (int64_t)block_align,
201
                         (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
202
    pos *= block_align;
203 4986a429 Fabrice Bellard
204
    /* recompute exact position */
205 77405fc8 Michael Niedermayer
    st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
206 4986a429 Fabrice Bellard
    url_fseek(&s->pb, pos + s->data_offset, SEEK_SET);
207
    return 0;
208
}
209
210 cd66005d Fabrice Bellard
/* ac3 read */
211
static int ac3_read_header(AVFormatContext *s,
212
                           AVFormatParameters *ap)
213
{
214
    AVStream *st;
215
216
    st = av_new_stream(s, 0);
217
    if (!st)
218
        return AVERROR_NOMEM;
219
220 01f4895c Michael Niedermayer
    st->codec->codec_type = CODEC_TYPE_AUDIO;
221
    st->codec->codec_id = CODEC_ID_AC3;
222 4986a429 Fabrice Bellard
    st->need_parsing = 1;
223 cd66005d Fabrice Bellard
    /* the parameters will be extracted from the compressed bitstream */
224
    return 0;
225
}
226
227 85ad5695 Michael Niedermayer
static int shorten_read_header(AVFormatContext *s,
228
                               AVFormatParameters *ap)
229
{
230
    AVStream *st;
231
232
    st = av_new_stream(s, 0);
233
    if (!st)
234
        return AVERROR_NOMEM;
235 01f4895c Michael Niedermayer
    st->codec->codec_type = CODEC_TYPE_AUDIO;
236
    st->codec->codec_id = CODEC_ID_SHORTEN;
237 85ad5695 Michael Niedermayer
    st->need_parsing = 1;
238
    /* the parameters will be extracted from the compressed bitstream */
239
    return 0;
240
}
241
242 23c99253 Michael Niedermayer
/* dts read */
243
static int dts_read_header(AVFormatContext *s,
244
                           AVFormatParameters *ap)
245
{
246
    AVStream *st;
247
248
    st = av_new_stream(s, 0);
249
    if (!st)
250
        return AVERROR_NOMEM;
251
252 01f4895c Michael Niedermayer
    st->codec->codec_type = CODEC_TYPE_AUDIO;
253
    st->codec->codec_id = CODEC_ID_DTS;
254 23c99253 Michael Niedermayer
    st->need_parsing = 1;
255
    /* the parameters will be extracted from the compressed bitstream */
256
    return 0;
257
}
258
259 de6d9b64 Fabrice Bellard
/* mpeg1/h263 input */
260
static int video_read_header(AVFormatContext *s,
261
                             AVFormatParameters *ap)
262
{
263
    AVStream *st;
264
265 c9a65ca8 Fabrice Bellard
    st = av_new_stream(s, 0);
266 de6d9b64 Fabrice Bellard
    if (!st)
267 c9a65ca8 Fabrice Bellard
        return AVERROR_NOMEM;
268 de6d9b64 Fabrice Bellard
269 01f4895c Michael Niedermayer
    st->codec->codec_type = CODEC_TYPE_VIDEO;
270
    st->codec->codec_id = s->iformat->value;
271 4986a429 Fabrice Bellard
    st->need_parsing = 1;
272
273 27e084bd Fabrice Bellard
    /* for mjpeg, specify frame rate */
274 7866eeff Michael Niedermayer
    /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
275 80ce3254 Michael Niedermayer
    if (ap && ap->time_base.num) {
276
        av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
277 01f4895c Michael Niedermayer
    } else if ( st->codec->codec_id == CODEC_ID_MJPEG || 
278
                st->codec->codec_id == CODEC_ID_MPEG4 ||
279
                st->codec->codec_id == CODEC_ID_H264) {
280 80ce3254 Michael Niedermayer
        av_set_pts_info(st, 64, 1, 25);
281 27e084bd Fabrice Bellard
    }
282 80ce3254 Michael Niedermayer
283 de6d9b64 Fabrice Bellard
    return 0;
284
}
285
286 c9a65ca8 Fabrice Bellard
#define SEQ_START_CODE                0x000001b3
287
#define GOP_START_CODE                0x000001b8
288
#define PICTURE_START_CODE        0x00000100
289
290
/* XXX: improve that by looking at several start codes */
291
static int mpegvideo_probe(AVProbeData *p)
292
{
293 fa777321 Fabrice Bellard
    int code;
294
    const uint8_t *d;
295 c9a65ca8 Fabrice Bellard
296
    /* we search the first start code. If it is a sequence, gop or
297
       picture start code then we decide it is an mpeg video
298
       stream. We do not send highest value to give a chance to mpegts */
299 fa777321 Fabrice Bellard
    /* NOTE: the search range was restricted to avoid too many false
300
       detections */
301
302
    if (p->buf_size < 6)
303
        return 0;
304
    d = p->buf;
305
    code = (d[0] << 24) | (d[1] << 16) | (d[2] << 8) | (d[3]);
306
    if ((code & 0xffffff00) == 0x100) {
307
        if (code == SEQ_START_CODE ||
308
            code == GOP_START_CODE ||
309
            code == PICTURE_START_CODE)
310
            return 50 - 1;
311
        else
312
            return 0;
313 c9a65ca8 Fabrice Bellard
    }
314
    return 0;
315
}
316
317 d07f9043 Michael Niedermayer
static int h263_probe(AVProbeData *p)
318
{
319
    int code;
320
    const uint8_t *d;
321
322
    if (p->buf_size < 6)
323
        return 0;
324
    d = p->buf;
325
    code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
326
    if (code == 0x20) {
327
        return 50;
328
    }
329
    return 0;
330
}
331
332 c6148de2 Michael Niedermayer
static int h261_probe(AVProbeData *p)
333
{
334
    int code;
335
    const uint8_t *d;
336
337
    if (p->buf_size < 6)
338
        return 0;
339
    d = p->buf;
340
    code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
341
    if (code == 0x10) {
342
        return 50;
343
    }
344
    return 0;
345
}
346
347 85ad5695 Michael Niedermayer
AVInputFormat shorten_iformat = {
348
    "shn",
349 84c63c01 Alex Beregszaszi
    "raw shorten",
350 85ad5695 Michael Niedermayer
    0,
351
    NULL,
352
    shorten_read_header,
353
    raw_read_partial_packet,
354
    raw_read_close,
355
    .extensions = "shn",
356
};
357
358 c9a65ca8 Fabrice Bellard
AVInputFormat ac3_iformat = {
359
    "ac3",
360
    "raw ac3",
361
    0,
362
    NULL,
363 cd66005d Fabrice Bellard
    ac3_read_header,
364 e15dec10 Leon van Stuivenberg
    raw_read_partial_packet,
365 de6d9b64 Fabrice Bellard
    raw_read_close,
366 bb76a117 Måns Rullgård
    .extensions = "ac3",
367 de6d9b64 Fabrice Bellard
};
368
369 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
370 c9a65ca8 Fabrice Bellard
AVOutputFormat ac3_oformat = {
371 de6d9b64 Fabrice Bellard
    "ac3",
372
    "raw ac3",
373
    "audio/x-ac3", 
374
    "ac3",
375 c9a65ca8 Fabrice Bellard
    0,
376 de6d9b64 Fabrice Bellard
    CODEC_ID_AC3,
377
    0,
378
    raw_write_header,
379
    raw_write_packet,
380
    raw_write_trailer,
381
};
382 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
383 de6d9b64 Fabrice Bellard
384 23c99253 Michael Niedermayer
AVInputFormat dts_iformat = {
385
    "dts",
386
    "raw dts",
387
    0,
388
    NULL,
389
    dts_read_header,
390
    raw_read_partial_packet,
391
    raw_read_close,
392
    .extensions = "dts",
393
};
394
395 c6148de2 Michael Niedermayer
AVInputFormat h261_iformat = {
396
    "h261",
397
    "raw h261",
398
    0,
399
    h261_probe,
400
    video_read_header,
401
    raw_read_partial_packet,
402
    raw_read_close,
403
    .extensions = "h261",
404
    .value = CODEC_ID_H261,
405
};
406
407 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
408 1c3990db Michael Niedermayer
AVOutputFormat h261_oformat = {
409
    "h261",
410
    "raw h261",
411
    "video/x-h261",
412
    "h261",
413
    0,
414
    0,
415
    CODEC_ID_H261,
416
    raw_write_header,
417
    raw_write_packet,
418
    raw_write_trailer,
419
};
420 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
421 1c3990db Michael Niedermayer
422 d07f9043 Michael Niedermayer
AVInputFormat h263_iformat = {
423
    "h263",
424
    "raw h263",
425
    0,
426
    h263_probe,
427
    video_read_header,
428 e15dec10 Leon van Stuivenberg
    raw_read_partial_packet,
429 d07f9043 Michael Niedermayer
    raw_read_close,
430
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
431
    .value = CODEC_ID_H263,
432
};
433
434 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
435 c9a65ca8 Fabrice Bellard
AVOutputFormat h263_oformat = {
436 de6d9b64 Fabrice Bellard
    "h263",
437
    "raw h263",
438
    "video/x-h263",
439
    "h263",
440
    0,
441 c9a65ca8 Fabrice Bellard
    0,
442 de6d9b64 Fabrice Bellard
    CODEC_ID_H263,
443
    raw_write_header,
444
    raw_write_packet,
445
    raw_write_trailer,
446 c9a65ca8 Fabrice Bellard
};
447 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
448 c9a65ca8 Fabrice Bellard
449 7866eeff Michael Niedermayer
AVInputFormat m4v_iformat = {
450
    "m4v",
451
    "raw MPEG4 video format",
452
    0,
453 2f0f5b20 Michael Niedermayer
    NULL /*mpegvideo_probe*/,
454 7866eeff Michael Niedermayer
    video_read_header,
455 e15dec10 Leon van Stuivenberg
    raw_read_partial_packet,
456 7866eeff Michael Niedermayer
    raw_read_close,
457 bb76a117 Måns Rullgård
    .extensions = "m4v", //FIXME remove after writing mpeg4_probe
458
    .value = CODEC_ID_MPEG4,
459 7866eeff Michael Niedermayer
};
460
461 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
462 89b3d7c9 Max Krasnyansky
AVOutputFormat m4v_oformat = {
463
    "m4v",
464
    "raw MPEG4 video format",
465
    NULL,
466
    "m4v",
467
    0,
468
    CODEC_ID_NONE,
469
    CODEC_ID_MPEG4,
470
    raw_write_header,
471
    raw_write_packet,
472
    raw_write_trailer,
473
};
474 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
475 89b3d7c9 Max Krasnyansky
476 0da71265 Michael Niedermayer
AVInputFormat h264_iformat = {
477
    "h264",
478
    "raw H264 video format",
479
    0,
480
    NULL /*mpegvideo_probe*/,
481
    video_read_header,
482 e15dec10 Leon van Stuivenberg
    raw_read_partial_packet,
483 0da71265 Michael Niedermayer
    raw_read_close,
484 ba5697d5 Michael Niedermayer
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
485 0da71265 Michael Niedermayer
    .value = CODEC_ID_H264,
486
};
487
488 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
489 0da71265 Michael Niedermayer
AVOutputFormat h264_oformat = {
490
    "h264",
491
    "raw H264 video format",
492
    NULL,
493
    "h264",
494
    0,
495
    CODEC_ID_NONE,
496
    CODEC_ID_H264,
497
    raw_write_header,
498
    raw_write_packet,
499
    raw_write_trailer,
500
};
501 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
502 0da71265 Michael Niedermayer
503 c9a65ca8 Fabrice Bellard
AVInputFormat mpegvideo_iformat = {
504
    "mpegvideo",
505
    "MPEG video",
506
    0,
507
    mpegvideo_probe,
508 de6d9b64 Fabrice Bellard
    video_read_header,
509 e15dec10 Leon van Stuivenberg
    raw_read_partial_packet,
510 de6d9b64 Fabrice Bellard
    raw_read_close,
511 bb76a117 Måns Rullgård
    .value = CODEC_ID_MPEG1VIDEO,
512 de6d9b64 Fabrice Bellard
};
513
514 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
515 c9a65ca8 Fabrice Bellard
AVOutputFormat mpeg1video_oformat = {
516
    "mpeg1video",
517 de6d9b64 Fabrice Bellard
    "MPEG video",
518
    "video/x-mpeg",
519 e0827ba4 Michael Niedermayer
    "mpg,mpeg,m1v",
520 de6d9b64 Fabrice Bellard
    0,
521 c9a65ca8 Fabrice Bellard
    0,
522 de6d9b64 Fabrice Bellard
    CODEC_ID_MPEG1VIDEO,
523
    raw_write_header,
524
    raw_write_packet,
525
    raw_write_trailer,
526
};
527 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
528 de6d9b64 Fabrice Bellard
529 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
530 6ec864da Michael Niedermayer
AVOutputFormat mpeg2video_oformat = {
531
    "mpeg2video",
532
    "MPEG2 video",
533
    NULL,
534
    "m2v",
535
    0,
536
    0,
537
    CODEC_ID_MPEG2VIDEO,
538
    raw_write_header,
539
    raw_write_packet,
540
    raw_write_trailer,
541
};
542 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
543 6ec864da Michael Niedermayer
544 c9a65ca8 Fabrice Bellard
AVInputFormat mjpeg_iformat = {
545 27e084bd Fabrice Bellard
    "mjpeg",
546
    "MJPEG video",
547
    0,
548 c9a65ca8 Fabrice Bellard
    NULL,
549 27e084bd Fabrice Bellard
    video_read_header,
550 e15dec10 Leon van Stuivenberg
    raw_read_partial_packet,
551 27e084bd Fabrice Bellard
    raw_read_close,
552 bb76a117 Måns Rullgård
    .extensions = "mjpg,mjpeg",
553
    .value = CODEC_ID_MJPEG,
554 27e084bd Fabrice Bellard
};
555
556 84c63c01 Alex Beregszaszi
AVInputFormat ingenient_iformat = {
557
    "ingenient",
558
    "Ingenient MJPEG",
559
    0,
560
    NULL,
561
    video_read_header,
562
    ingenient_read_packet,
563
    raw_read_close,
564
    .extensions = "cgi", // FIXME
565
    .value = CODEC_ID_MJPEG,
566
};
567
568 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
569 c9a65ca8 Fabrice Bellard
AVOutputFormat mjpeg_oformat = {
570
    "mjpeg",
571
    "MJPEG video",
572
    "video/x-mjpeg",
573
    "mjpg,mjpeg",
574 5ed8fafc Fabrice Bellard
    0,
575
    0,
576 c9a65ca8 Fabrice Bellard
    CODEC_ID_MJPEG,
577 5ed8fafc Fabrice Bellard
    raw_write_header,
578
    raw_write_packet,
579
    raw_write_trailer,
580
};
581 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
582 5ed8fafc Fabrice Bellard
583 c9a65ca8 Fabrice Bellard
/* pcm formats */
584 764ef400 Mike Melanson
585 4986a429 Fabrice Bellard
#define PCMINPUTDEF(name, long_name, ext, codec) \
586 764ef400 Mike Melanson
AVInputFormat pcm_ ## name ## _iformat = {\
587
    #name,\
588
    long_name,\
589
    0,\
590
    NULL,\
591
    raw_read_header,\
592
    raw_read_packet,\
593
    raw_read_close,\
594 4986a429 Fabrice Bellard
    pcm_read_seek,\
595 764ef400 Mike Melanson
    .extensions = ext,\
596
    .value = codec,\
597
};
598
599 a9e35095 Diego Biurrun
#if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
600 4986a429 Fabrice Bellard
601
#define PCMDEF(name, long_name, ext, codec) \
602
    PCMINPUTDEF(name, long_name, ext, codec)
603
604 764ef400 Mike Melanson
#else
605 5ed8fafc Fabrice Bellard
606 c9a65ca8 Fabrice Bellard
#define PCMDEF(name, long_name, ext, codec) \
607 4986a429 Fabrice Bellard
    PCMINPUTDEF(name, long_name, ext, codec)\
608 c9a65ca8 Fabrice Bellard
\
609
AVOutputFormat pcm_ ## name ## _oformat = {\
610
    #name,\
611
    long_name,\
612
    NULL,\
613
    ext,\
614
    0,\
615
    codec,\
616
    0,\
617
    raw_write_header,\
618
    raw_write_packet,\
619
    raw_write_trailer,\
620 5ed8fafc Fabrice Bellard
};
621 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
622 5ed8fafc Fabrice Bellard
623
#ifdef WORDS_BIGENDIAN
624 c9a65ca8 Fabrice Bellard
#define BE_DEF(s) s
625
#define LE_DEF(s) NULL
626 5ed8fafc Fabrice Bellard
#else
627 c9a65ca8 Fabrice Bellard
#define BE_DEF(s) NULL
628
#define LE_DEF(s) s
629 5ed8fafc Fabrice Bellard
#endif
630
631
632 c9a65ca8 Fabrice Bellard
PCMDEF(s16le, "pcm signed 16 bit little endian format", 
633
       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
634 5ed8fafc Fabrice Bellard
635 c9a65ca8 Fabrice Bellard
PCMDEF(s16be, "pcm signed 16 bit big endian format", 
636
       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
637 5ed8fafc Fabrice Bellard
638 c9a65ca8 Fabrice Bellard
PCMDEF(u16le, "pcm unsigned 16 bit little endian format", 
639
       LE_DEF("uw"), CODEC_ID_PCM_U16LE)
640 5ed8fafc Fabrice Bellard
641 c9a65ca8 Fabrice Bellard
PCMDEF(u16be, "pcm unsigned 16 bit big endian format", 
642
       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
643 5ed8fafc Fabrice Bellard
644 c9a65ca8 Fabrice Bellard
PCMDEF(s8, "pcm signed 8 bit format", 
645
       "sb", CODEC_ID_PCM_S8)
646 5ed8fafc Fabrice Bellard
647 c9a65ca8 Fabrice Bellard
PCMDEF(u8, "pcm unsigned 8 bit format", 
648
       "ub", CODEC_ID_PCM_U8)
649 5ed8fafc Fabrice Bellard
650 c9a65ca8 Fabrice Bellard
PCMDEF(mulaw, "pcm mu law format", 
651
       "ul", CODEC_ID_PCM_MULAW)
652 de6d9b64 Fabrice Bellard
653 c9a65ca8 Fabrice Bellard
PCMDEF(alaw, "pcm A law format", 
654
       "al", CODEC_ID_PCM_ALAW)
655 de6d9b64 Fabrice Bellard
656 5c91a675 Zdenek Kabelac
static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
657 de6d9b64 Fabrice Bellard
{
658
    int packet_size, ret, width, height;
659
    AVStream *st = s->streams[0];
660
661 01f4895c Michael Niedermayer
    width = st->codec->width;
662
    height = st->codec->height;
663 de6d9b64 Fabrice Bellard
664 01f4895c Michael Niedermayer
    packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
665 63167088 Roman Shaposhnik
    if (packet_size < 0)
666 71c32f19 Michael Niedermayer
        return -1;
667 de6d9b64 Fabrice Bellard
668 2692067a Michael Niedermayer
    ret= av_get_packet(&s->pb, pkt, packet_size);
669 de6d9b64 Fabrice Bellard
670
    pkt->stream_index = 0;
671 2692067a Michael Niedermayer
    if (ret != packet_size) {
672 0bd586c5 Mike Melanson
        return AVERROR_IO;
673 de6d9b64 Fabrice Bellard
    } else {
674
        return 0;
675
    }
676
}
677
678 c9a65ca8 Fabrice Bellard
AVInputFormat rawvideo_iformat = {
679
    "rawvideo",
680
    "raw video format",
681
    0,
682
    NULL,
683
    raw_read_header,
684
    rawvideo_read_packet,
685
    raw_read_close,
686 bfc7f165 Michael Niedermayer
    .extensions = "yuv,cif,qcif",
687 bb76a117 Måns Rullgård
    .value = CODEC_ID_RAWVIDEO,
688 c9a65ca8 Fabrice Bellard
};
689
690 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
691 c9a65ca8 Fabrice Bellard
AVOutputFormat rawvideo_oformat = {
692 de6d9b64 Fabrice Bellard
    "rawvideo",
693
    "raw video format",
694
    NULL,
695
    "yuv",
696 c9a65ca8 Fabrice Bellard
    0,
697 de6d9b64 Fabrice Bellard
    CODEC_ID_NONE,
698
    CODEC_ID_RAWVIDEO,
699
    raw_write_header,
700
    raw_write_packet,
701
    raw_write_trailer,
702
};
703 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
704 c9a65ca8 Fabrice Bellard
705 a9e35095 Diego Biurrun
#ifdef CONFIG_MUXERS
706 e928649b Michael Niedermayer
static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
707 87bdd3e5 Fabrice Bellard
{
708
    return 0;
709
}
710
711
AVOutputFormat null_oformat = {
712
    "null",
713
    "null video format",
714
    NULL,
715
    NULL,
716
    0,
717
#ifdef WORDS_BIGENDIAN
718
    CODEC_ID_PCM_S16BE,
719
#else
720
    CODEC_ID_PCM_S16LE,
721
#endif
722
    CODEC_ID_RAWVIDEO,
723
    raw_write_header,
724
    null_write_packet,
725
    raw_write_trailer,
726 b1d89f82 Måns Rullgård
    .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE,
727 87bdd3e5 Fabrice Bellard
};
728 a9e35095 Diego Biurrun
#endif //CONFIG_MUXERS
729 764ef400 Mike Melanson
730 a9e35095 Diego Biurrun
#ifndef CONFIG_MUXERS
731 764ef400 Mike Melanson
#define av_register_output_format(format)
732
#endif
733 a9e35095 Diego Biurrun
#ifndef CONFIG_DEMUXERS
734 764ef400 Mike Melanson
#define av_register_input_format(format)
735
#endif
736 87bdd3e5 Fabrice Bellard
737 c9a65ca8 Fabrice Bellard
int raw_init(void)
738
{
739 85ad5695 Michael Niedermayer
740
    av_register_input_format(&shorten_iformat);
741
742 c9a65ca8 Fabrice Bellard
    av_register_input_format(&ac3_iformat);
743
    av_register_output_format(&ac3_oformat);
744
745 23c99253 Michael Niedermayer
    av_register_input_format(&dts_iformat);
746
747 c6148de2 Michael Niedermayer
    av_register_input_format(&h261_iformat);
748 1c3990db Michael Niedermayer
    av_register_output_format(&h261_oformat);
749 c6148de2 Michael Niedermayer
750 d07f9043 Michael Niedermayer
    av_register_input_format(&h263_iformat);
751 c9a65ca8 Fabrice Bellard
    av_register_output_format(&h263_oformat);
752 89b3d7c9 Max Krasnyansky
    
753 7866eeff Michael Niedermayer
    av_register_input_format(&m4v_iformat);
754 89b3d7c9 Max Krasnyansky
    av_register_output_format(&m4v_oformat);
755 0da71265 Michael Niedermayer
    
756
    av_register_input_format(&h264_iformat);
757
    av_register_output_format(&h264_oformat);
758 c9a65ca8 Fabrice Bellard
759
    av_register_input_format(&mpegvideo_iformat);
760
    av_register_output_format(&mpeg1video_oformat);
761
762 6ec864da Michael Niedermayer
    av_register_output_format(&mpeg2video_oformat);
763
764 c9a65ca8 Fabrice Bellard
    av_register_input_format(&mjpeg_iformat);
765
    av_register_output_format(&mjpeg_oformat);
766 84c63c01 Alex Beregszaszi
    
767
    av_register_input_format(&ingenient_iformat);
768 c9a65ca8 Fabrice Bellard
769
    av_register_input_format(&pcm_s16le_iformat);
770
    av_register_output_format(&pcm_s16le_oformat);
771
    av_register_input_format(&pcm_s16be_iformat);
772
    av_register_output_format(&pcm_s16be_oformat);
773
    av_register_input_format(&pcm_u16le_iformat);
774
    av_register_output_format(&pcm_u16le_oformat);
775
    av_register_input_format(&pcm_u16be_iformat);
776
    av_register_output_format(&pcm_u16be_oformat);
777
    av_register_input_format(&pcm_s8_iformat);
778
    av_register_output_format(&pcm_s8_oformat);
779
    av_register_input_format(&pcm_u8_iformat);
780
    av_register_output_format(&pcm_u8_oformat);
781
    av_register_input_format(&pcm_mulaw_iformat);
782
    av_register_output_format(&pcm_mulaw_oformat);
783
    av_register_input_format(&pcm_alaw_iformat);
784
    av_register_output_format(&pcm_alaw_oformat);
785
786
    av_register_input_format(&rawvideo_iformat);
787
    av_register_output_format(&rawvideo_oformat);
788 87bdd3e5 Fabrice Bellard
789
    av_register_output_format(&null_oformat);
790 c9a65ca8 Fabrice Bellard
    return 0;
791
}