Statistics
| Branch: | Revision:

ffmpeg / libavformat / raw.c @ 25f8db58

History | View | Annotate | Download (18 KB)

1
/* 
2
 * RAW encoder and decoder
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 * Copyright (c) 2005 Alex Beregszaszi
5
 *
6
 * 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
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * 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
 */
20
#include "avformat.h"
21

    
22
#ifdef CONFIG_MUXERS
23
/* simple formats */
24
static int raw_write_header(struct AVFormatContext *s)
25
{
26
    return 0;
27
}
28

    
29
static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
30
{
31
    put_buffer(&s->pb, pkt->data, pkt->size);
32
    put_flush_packet(&s->pb);
33
    return 0;
34
}
35

    
36
static int raw_write_trailer(struct AVFormatContext *s)
37
{
38
    return 0;
39
}
40
#endif //CONFIG_MUXERS
41

    
42
/* raw input */
43
static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
44
{
45
    AVStream *st;
46
    int id;
47

    
48
    st = av_new_stream(s, 0);
49
    if (!st)
50
        return AVERROR_NOMEM;
51
    if (ap) {
52
        id = s->iformat->value;
53
        if (id == CODEC_ID_RAWVIDEO) {
54
            st->codec->codec_type = CODEC_TYPE_VIDEO;
55
        } else {
56
            st->codec->codec_type = CODEC_TYPE_AUDIO;
57
        }
58
        st->codec->codec_id = id;
59

    
60
        switch(st->codec->codec_type) {
61
        case CODEC_TYPE_AUDIO:
62
            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
            break;
66
        case CODEC_TYPE_VIDEO:
67
            av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
68
            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
            break;
74
        default:
75
            return -1;
76
        }
77
    } else {
78
        return -1;
79
    }
80
    return 0;
81
}
82

    
83
#define RAW_PACKET_SIZE 1024
84

    
85
static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
86
{
87
    int ret, size;
88
    //    AVStream *st = s->streams[0];
89
    
90
    size= RAW_PACKET_SIZE;
91

    
92
    ret= av_get_packet(&s->pb, pkt, size);
93

    
94
    pkt->stream_index = 0;
95
    if (ret <= 0) {
96
        return AVERROR_IO;
97
    }
98
    /* note: we need to modify the packet size here to handle the last
99
       packet */
100
    pkt->size = ret;
101
    return ret;
102
}
103

    
104
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
        return AVERROR_IO;
112
    
113
    pkt->pos= url_ftell(&s->pb);
114
    pkt->stream_index = 0;
115
    ret = get_partial_buffer(&s->pb, pkt->data, size);
116
    if (ret <= 0) {
117
        av_free_packet(pkt);
118
        return AVERROR_IO;
119
    }
120
    pkt->size = ret;
121
    return ret;
122
}
123

    
124
// 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
static int raw_read_close(AVFormatContext *s)
161
{
162
    return 0;
163
}
164

    
165
int pcm_read_seek(AVFormatContext *s, 
166
                  int stream_index, int64_t timestamp, int flags)
167
{
168
    AVStream *st;
169
    int block_align, byte_rate;
170
    int64_t pos;
171

    
172
    st = s->streams[0];
173
    switch(st->codec->codec_id) {
174
    case CODEC_ID_PCM_S16LE:
175
    case CODEC_ID_PCM_S16BE:
176
    case CODEC_ID_PCM_U16LE:
177
    case CODEC_ID_PCM_U16BE:
178
        block_align = 2 * st->codec->channels;
179
        byte_rate = block_align * st->codec->sample_rate;
180
        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
        block_align = st->codec->channels;
186
        byte_rate = block_align * st->codec->sample_rate;
187
        break;
188
    default:
189
        block_align = st->codec->block_align;
190
        byte_rate = st->codec->bit_rate / 8;
191
        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
    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

    
204
    /* recompute exact position */
205
    st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
206
    url_fseek(&s->pb, pos + s->data_offset, SEEK_SET);
207
    return 0;
208
}
209

    
210
/* 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
    st->codec->codec_type = CODEC_TYPE_AUDIO;
221
    st->codec->codec_id = CODEC_ID_AC3;
222
    st->need_parsing = 1;
223
    /* the parameters will be extracted from the compressed bitstream */
224
    return 0;
225
}
226

    
227
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
    st->codec->codec_type = CODEC_TYPE_AUDIO;
236
    st->codec->codec_id = CODEC_ID_SHORTEN;
237
    st->need_parsing = 1;
238
    /* the parameters will be extracted from the compressed bitstream */
239
    return 0;
240
}
241

    
242
/* 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
    st->codec->codec_type = CODEC_TYPE_AUDIO;
253
    st->codec->codec_id = CODEC_ID_DTS;
254
    st->need_parsing = 1;
255
    /* the parameters will be extracted from the compressed bitstream */
256
    return 0;
257
}
258

    
259
/* mpeg1/h263 input */
260
static int video_read_header(AVFormatContext *s,
261
                             AVFormatParameters *ap)
262
{
263
    AVStream *st;
264

    
265
    st = av_new_stream(s, 0);
266
    if (!st)
267
        return AVERROR_NOMEM;
268

    
269
    st->codec->codec_type = CODEC_TYPE_VIDEO;
270
    st->codec->codec_id = s->iformat->value;
271
    st->need_parsing = 1;
272

    
273
    /* for mjpeg, specify frame rate */
274
    /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
275
    if (ap && ap->time_base.num) {
276
        av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
277
    } 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
        av_set_pts_info(st, 64, 1, 25);
281
    }
282

    
283
    return 0;
284
}
285

    
286
#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
    int code;
294
    const uint8_t *d;
295

    
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
    /* 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
    }
314
    return 0;
315
}
316

    
317
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
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
AVInputFormat shorten_iformat = {
348
    "shn",
349
    "raw shorten",
350
    0,
351
    NULL,
352
    shorten_read_header,
353
    raw_read_partial_packet,
354
    raw_read_close,
355
    .extensions = "shn",
356
};
357

    
358
AVInputFormat ac3_iformat = {
359
    "ac3",
360
    "raw ac3",
361
    0,
362
    NULL,
363
    ac3_read_header,
364
    raw_read_partial_packet,
365
    raw_read_close,
366
    .extensions = "ac3",
367
};
368

    
369
#ifdef CONFIG_MUXERS
370
AVOutputFormat ac3_oformat = {
371
    "ac3",
372
    "raw ac3",
373
    "audio/x-ac3", 
374
    "ac3",
375
    0,
376
    CODEC_ID_AC3,
377
    0,
378
    raw_write_header,
379
    raw_write_packet,
380
    raw_write_trailer,
381
};
382
#endif //CONFIG_MUXERS
383

    
384
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
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
#ifdef CONFIG_MUXERS
408
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
#endif //CONFIG_MUXERS
421

    
422
AVInputFormat h263_iformat = {
423
    "h263",
424
    "raw h263",
425
    0,
426
    h263_probe,
427
    video_read_header,
428
    raw_read_partial_packet,
429
    raw_read_close,
430
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
431
    .value = CODEC_ID_H263,
432
};
433

    
434
#ifdef CONFIG_MUXERS
435
AVOutputFormat h263_oformat = {
436
    "h263",
437
    "raw h263",
438
    "video/x-h263",
439
    "h263",
440
    0,
441
    0,
442
    CODEC_ID_H263,
443
    raw_write_header,
444
    raw_write_packet,
445
    raw_write_trailer,
446
};
447
#endif //CONFIG_MUXERS
448

    
449
AVInputFormat m4v_iformat = {
450
    "m4v",
451
    "raw MPEG4 video format",
452
    0,
453
    NULL /*mpegvideo_probe*/,
454
    video_read_header,
455
    raw_read_partial_packet,
456
    raw_read_close,
457
    .extensions = "m4v", //FIXME remove after writing mpeg4_probe
458
    .value = CODEC_ID_MPEG4,
459
};
460

    
461
#ifdef CONFIG_MUXERS
462
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
#endif //CONFIG_MUXERS
475

    
476
AVInputFormat h264_iformat = {
477
    "h264",
478
    "raw H264 video format",
479
    0,
480
    NULL /*mpegvideo_probe*/,
481
    video_read_header,
482
    raw_read_partial_packet,
483
    raw_read_close,
484
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
485
    .value = CODEC_ID_H264,
486
};
487

    
488
#ifdef CONFIG_MUXERS
489
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
#endif //CONFIG_MUXERS
502

    
503
AVInputFormat mpegvideo_iformat = {
504
    "mpegvideo",
505
    "MPEG video",
506
    0,
507
    mpegvideo_probe,
508
    video_read_header,
509
    raw_read_partial_packet,
510
    raw_read_close,
511
    .value = CODEC_ID_MPEG1VIDEO,
512
};
513

    
514
#ifdef CONFIG_MUXERS
515
AVOutputFormat mpeg1video_oformat = {
516
    "mpeg1video",
517
    "MPEG video",
518
    "video/x-mpeg",
519
    "mpg,mpeg,m1v",
520
    0,
521
    0,
522
    CODEC_ID_MPEG1VIDEO,
523
    raw_write_header,
524
    raw_write_packet,
525
    raw_write_trailer,
526
};
527
#endif //CONFIG_MUXERS
528

    
529
#ifdef CONFIG_MUXERS
530
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
#endif //CONFIG_MUXERS
543

    
544
AVInputFormat mjpeg_iformat = {
545
    "mjpeg",
546
    "MJPEG video",
547
    0,
548
    NULL,
549
    video_read_header,
550
    raw_read_partial_packet,
551
    raw_read_close,
552
    .extensions = "mjpg,mjpeg",
553
    .value = CODEC_ID_MJPEG,
554
};
555

    
556
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
#ifdef CONFIG_MUXERS
569
AVOutputFormat mjpeg_oformat = {
570
    "mjpeg",
571
    "MJPEG video",
572
    "video/x-mjpeg",
573
    "mjpg,mjpeg",
574
    0,
575
    0,
576
    CODEC_ID_MJPEG,
577
    raw_write_header,
578
    raw_write_packet,
579
    raw_write_trailer,
580
};
581
#endif //CONFIG_MUXERS
582

    
583
/* pcm formats */
584

    
585
#define PCMINPUTDEF(name, long_name, ext, codec) \
586
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
    pcm_read_seek,\
595
    .extensions = ext,\
596
    .value = codec,\
597
};
598

    
599
#if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
600

    
601
#define PCMDEF(name, long_name, ext, codec) \
602
    PCMINPUTDEF(name, long_name, ext, codec)
603

    
604
#else
605

    
606
#define PCMDEF(name, long_name, ext, codec) \
607
    PCMINPUTDEF(name, long_name, ext, codec)\
608
\
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
};
621
#endif //CONFIG_MUXERS
622

    
623
#ifdef WORDS_BIGENDIAN
624
#define BE_DEF(s) s
625
#define LE_DEF(s) NULL
626
#else
627
#define BE_DEF(s) NULL
628
#define LE_DEF(s) s
629
#endif
630

    
631

    
632
PCMDEF(s16le, "pcm signed 16 bit little endian format", 
633
       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
634

    
635
PCMDEF(s16be, "pcm signed 16 bit big endian format", 
636
       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
637

    
638
PCMDEF(u16le, "pcm unsigned 16 bit little endian format", 
639
       LE_DEF("uw"), CODEC_ID_PCM_U16LE)
640

    
641
PCMDEF(u16be, "pcm unsigned 16 bit big endian format", 
642
       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
643

    
644
PCMDEF(s8, "pcm signed 8 bit format", 
645
       "sb", CODEC_ID_PCM_S8)
646

    
647
PCMDEF(u8, "pcm unsigned 8 bit format", 
648
       "ub", CODEC_ID_PCM_U8)
649

    
650
PCMDEF(mulaw, "pcm mu law format", 
651
       "ul", CODEC_ID_PCM_MULAW)
652

    
653
PCMDEF(alaw, "pcm A law format", 
654
       "al", CODEC_ID_PCM_ALAW)
655

    
656
static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
657
{
658
    int packet_size, ret, width, height;
659
    AVStream *st = s->streams[0];
660

    
661
    width = st->codec->width;
662
    height = st->codec->height;
663

    
664
    packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
665
    if (packet_size < 0)
666
        return -1;
667

    
668
    ret= av_get_packet(&s->pb, pkt, packet_size);
669

    
670
    pkt->stream_index = 0;
671
    if (ret != packet_size) {
672
        return AVERROR_IO;
673
    } else {
674
        return 0;
675
    }
676
}
677

    
678
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
    .extensions = "yuv,cif,qcif",
687
    .value = CODEC_ID_RAWVIDEO,
688
};
689

    
690
#ifdef CONFIG_MUXERS
691
AVOutputFormat rawvideo_oformat = {
692
    "rawvideo",
693
    "raw video format",
694
    NULL,
695
    "yuv",
696
    0,
697
    CODEC_ID_NONE,
698
    CODEC_ID_RAWVIDEO,
699
    raw_write_header,
700
    raw_write_packet,
701
    raw_write_trailer,
702
};
703
#endif //CONFIG_MUXERS
704

    
705
#ifdef CONFIG_MUXERS
706
static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
707
{
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
    .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE,
727
};
728
#endif //CONFIG_MUXERS
729

    
730
#ifndef CONFIG_MUXERS
731
#define av_register_output_format(format)
732
#endif
733
#ifndef CONFIG_DEMUXERS
734
#define av_register_input_format(format)
735
#endif
736

    
737
int raw_init(void)
738
{
739

    
740
    av_register_input_format(&shorten_iformat);
741

    
742
    av_register_input_format(&ac3_iformat);
743
    av_register_output_format(&ac3_oformat);
744

    
745
    av_register_input_format(&dts_iformat);
746

    
747
    av_register_input_format(&h261_iformat);
748
    av_register_output_format(&h261_oformat);
749

    
750
    av_register_input_format(&h263_iformat);
751
    av_register_output_format(&h263_oformat);
752
    
753
    av_register_input_format(&m4v_iformat);
754
    av_register_output_format(&m4v_oformat);
755
    
756
    av_register_input_format(&h264_iformat);
757
    av_register_output_format(&h264_oformat);
758

    
759
    av_register_input_format(&mpegvideo_iformat);
760
    av_register_output_format(&mpeg1video_oformat);
761

    
762
    av_register_output_format(&mpeg2video_oformat);
763

    
764
    av_register_input_format(&mjpeg_iformat);
765
    av_register_output_format(&mjpeg_oformat);
766
    
767
    av_register_input_format(&ingenient_iformat);
768

    
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

    
789
    av_register_output_format(&null_oformat);
790
    return 0;
791
}