Statistics
| Branch: | Revision:

ffmpeg / libavformat / raw.c @ c04c3282

History | View | Annotate | Download (18.6 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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

    
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
    return 0;
78
}
79

    
80
#define RAW_PACKET_SIZE 1024
81

    
82
static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
83
{
84
    int ret, size;
85
    //    AVStream *st = s->streams[0];
86

    
87
    size= RAW_PACKET_SIZE;
88

    
89
    ret= av_get_packet(&s->pb, pkt, size);
90

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

    
101
static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
102
{
103
    int ret, size;
104

    
105
    size = RAW_PACKET_SIZE;
106

    
107
    if (av_new_packet(pkt, size) < 0)
108
        return AVERROR_IO;
109

    
110
    pkt->pos= url_ftell(&s->pb);
111
    pkt->stream_index = 0;
112
    ret = get_partial_buffer(&s->pb, pkt->data, size);
113
    if (ret <= 0) {
114
        av_free_packet(pkt);
115
        return AVERROR_IO;
116
    }
117
    pkt->size = ret;
118
    return ret;
119
}
120

    
121
// http://www.artificis.hu/files/texts/ingenient.txt
122
static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
123
{
124
    int ret, size, w, h, unk1, unk2;
125

    
126
    if (get_le32(&s->pb) != MKTAG('M', 'J', 'P', 'G'))
127
        return AVERROR_IO; // FIXME
128

    
129
    size = get_le32(&s->pb);
130

    
131
    w = get_le16(&s->pb);
132
    h = get_le16(&s->pb);
133

    
134
    url_fskip(&s->pb, 8); // zero + size (padded?)
135
    url_fskip(&s->pb, 2);
136
    unk1 = get_le16(&s->pb);
137
    unk2 = get_le16(&s->pb);
138
    url_fskip(&s->pb, 22); // ascii timestamp
139

    
140
    av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
141
        size, w, h, unk1, unk2);
142

    
143
    if (av_new_packet(pkt, size) < 0)
144
        return AVERROR_IO;
145

    
146
    pkt->pos = url_ftell(&s->pb);
147
    pkt->stream_index = 0;
148
    ret = get_buffer(&s->pb, pkt->data, size);
149
    if (ret <= 0) {
150
        av_free_packet(pkt);
151
        return AVERROR_IO;
152
    }
153
    pkt->size = ret;
154
    return ret;
155
}
156

    
157
static int raw_read_close(AVFormatContext *s)
158
{
159
    return 0;
160
}
161

    
162
int pcm_read_seek(AVFormatContext *s,
163
                  int stream_index, int64_t timestamp, int flags)
164
{
165
    AVStream *st;
166
    int block_align, byte_rate;
167
    int64_t pos;
168

    
169
    st = s->streams[0];
170
    switch(st->codec->codec_id) {
171
    case CODEC_ID_PCM_S16LE:
172
    case CODEC_ID_PCM_S16BE:
173
    case CODEC_ID_PCM_U16LE:
174
    case CODEC_ID_PCM_U16BE:
175
        block_align = 2 * st->codec->channels;
176
        byte_rate = block_align * st->codec->sample_rate;
177
        break;
178
    case CODEC_ID_PCM_S8:
179
    case CODEC_ID_PCM_U8:
180
    case CODEC_ID_PCM_MULAW:
181
    case CODEC_ID_PCM_ALAW:
182
        block_align = st->codec->channels;
183
        byte_rate = block_align * st->codec->sample_rate;
184
        break;
185
    default:
186
        block_align = st->codec->block_align;
187
        byte_rate = st->codec->bit_rate / 8;
188
        break;
189
    }
190

    
191
    if (block_align <= 0 || byte_rate <= 0)
192
        return -1;
193

    
194
    /* compute the position by aligning it to block_align */
195
    pos = av_rescale_rnd(timestamp * byte_rate,
196
                         st->time_base.num,
197
                         st->time_base.den * (int64_t)block_align,
198
                         (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
199
    pos *= block_align;
200

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

    
207
/* ac3 read */
208
static int ac3_read_header(AVFormatContext *s,
209
                           AVFormatParameters *ap)
210
{
211
    AVStream *st;
212

    
213
    st = av_new_stream(s, 0);
214
    if (!st)
215
        return AVERROR_NOMEM;
216

    
217
    st->codec->codec_type = CODEC_TYPE_AUDIO;
218
    st->codec->codec_id = CODEC_ID_AC3;
219
    st->need_parsing = 1;
220
    /* the parameters will be extracted from the compressed bitstream */
221
    return 0;
222
}
223

    
224
static int shorten_read_header(AVFormatContext *s,
225
                               AVFormatParameters *ap)
226
{
227
    AVStream *st;
228

    
229
    st = av_new_stream(s, 0);
230
    if (!st)
231
        return AVERROR_NOMEM;
232
    st->codec->codec_type = CODEC_TYPE_AUDIO;
233
    st->codec->codec_id = CODEC_ID_SHORTEN;
234
    st->need_parsing = 1;
235
    /* the parameters will be extracted from the compressed bitstream */
236
    return 0;
237
}
238

    
239
/* dts read */
240
static int dts_read_header(AVFormatContext *s,
241
                           AVFormatParameters *ap)
242
{
243
    AVStream *st;
244

    
245
    st = av_new_stream(s, 0);
246
    if (!st)
247
        return AVERROR_NOMEM;
248

    
249
    st->codec->codec_type = CODEC_TYPE_AUDIO;
250
    st->codec->codec_id = CODEC_ID_DTS;
251
    st->need_parsing = 1;
252
    /* the parameters will be extracted from the compressed bitstream */
253
    return 0;
254
}
255

    
256
/* aac read */
257
static int aac_read_header(AVFormatContext *s,
258
                           AVFormatParameters *ap)
259
{
260
    AVStream *st;
261

    
262
    st = av_new_stream(s, 0);
263
    if (!st)
264
        return AVERROR_NOMEM;
265

    
266
    st->codec->codec_type = CODEC_TYPE_AUDIO;
267
    st->codec->codec_id = CODEC_ID_AAC;
268
    st->need_parsing = 1;
269
    /* the parameters will be extracted from the compressed bitstream */
270
    return 0;
271
}
272

    
273
/* mpeg1/h263 input */
274
static int video_read_header(AVFormatContext *s,
275
                             AVFormatParameters *ap)
276
{
277
    AVStream *st;
278

    
279
    st = av_new_stream(s, 0);
280
    if (!st)
281
        return AVERROR_NOMEM;
282

    
283
    st->codec->codec_type = CODEC_TYPE_VIDEO;
284
    st->codec->codec_id = s->iformat->value;
285
    st->need_parsing = 1;
286

    
287
    /* for mjpeg, specify frame rate */
288
    /* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
289
    if (ap->time_base.num) {
290
        av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
291
    } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
292
                st->codec->codec_id == CODEC_ID_MPEG4 ||
293
                st->codec->codec_id == CODEC_ID_H264) {
294
        av_set_pts_info(st, 64, 1, 25);
295
    }
296

    
297
    return 0;
298
}
299

    
300
#define SEQ_START_CODE          0x000001b3
301
#define GOP_START_CODE          0x000001b8
302
#define PICTURE_START_CODE      0x00000100
303
#define SLICE_START_CODE        0x00000101
304
#define PACK_START_CODE         0x000001ba
305
#define VIDEO_ID                0x000001e0
306
#define AUDIO_ID                0x000001c0
307

    
308
static int mpegvideo_probe(AVProbeData *p)
309
{
310
    uint32_t code= -1;
311
    int pic=0, seq=0, slice=0, pspack=0, pes=0;
312
    int i;
313

    
314
    for(i=0; i<p->buf_size; i++){
315
        code = (code<<8) + p->buf[i];
316
        if ((code & 0xffffff00) == 0x100) {
317
            switch(code){
318
            case     SEQ_START_CODE:   seq++; break;
319
            case PICTURE_START_CODE:   pic++; break;
320
            case   SLICE_START_CODE: slice++; break;
321
            case    PACK_START_CODE: pspack++; break;
322
            case           VIDEO_ID:
323
            case           AUDIO_ID:   pes++; break;
324
            }
325
        }
326
    }
327
    if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
328
        return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
329
    return 0;
330
}
331

    
332
static int h263_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] << 14) | (d[1] << 6) | (d[2] >> 2);
341
    if (code == 0x20) {
342
        return 50;
343
    }
344
    return 0;
345
}
346

    
347
static int h261_probe(AVProbeData *p)
348
{
349
    int code;
350
    const uint8_t *d;
351

    
352
    if (p->buf_size < 6)
353
        return 0;
354
    d = p->buf;
355
    code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
356
    if (code == 0x10) {
357
        return 50;
358
    }
359
    return 0;
360
}
361

    
362
AVInputFormat shorten_iformat = {
363
    "shn",
364
    "raw shorten",
365
    0,
366
    NULL,
367
    shorten_read_header,
368
    raw_read_partial_packet,
369
    raw_read_close,
370
    .extensions = "shn",
371
};
372

    
373
AVInputFormat ac3_iformat = {
374
    "ac3",
375
    "raw ac3",
376
    0,
377
    NULL,
378
    ac3_read_header,
379
    raw_read_partial_packet,
380
    raw_read_close,
381
    .extensions = "ac3",
382
};
383

    
384
#ifdef CONFIG_MUXERS
385
AVOutputFormat ac3_oformat = {
386
    "ac3",
387
    "raw ac3",
388
    "audio/x-ac3",
389
    "ac3",
390
    0,
391
    CODEC_ID_AC3,
392
    0,
393
    raw_write_header,
394
    raw_write_packet,
395
    raw_write_trailer,
396
};
397
#endif //CONFIG_MUXERS
398

    
399
AVInputFormat dts_iformat = {
400
    "dts",
401
    "raw dts",
402
    0,
403
    NULL,
404
    dts_read_header,
405
    raw_read_partial_packet,
406
    raw_read_close,
407
    .extensions = "dts",
408
};
409

    
410
AVInputFormat aac_iformat = {
411
    "aac",
412
    "ADTS AAC",
413
    0,
414
    NULL,
415
    aac_read_header,
416
    raw_read_partial_packet,
417
    raw_read_close,
418
    .extensions = "aac",
419
};
420

    
421
AVInputFormat h261_iformat = {
422
    "h261",
423
    "raw h261",
424
    0,
425
    h261_probe,
426
    video_read_header,
427
    raw_read_partial_packet,
428
    raw_read_close,
429
    .extensions = "h261",
430
    .value = CODEC_ID_H261,
431
};
432

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

    
448
AVInputFormat h263_iformat = {
449
    "h263",
450
    "raw h263",
451
    0,
452
    h263_probe,
453
    video_read_header,
454
    raw_read_partial_packet,
455
    raw_read_close,
456
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
457
    .value = CODEC_ID_H263,
458
};
459

    
460
#ifdef CONFIG_MUXERS
461
AVOutputFormat h263_oformat = {
462
    "h263",
463
    "raw h263",
464
    "video/x-h263",
465
    "h263",
466
    0,
467
    0,
468
    CODEC_ID_H263,
469
    raw_write_header,
470
    raw_write_packet,
471
    raw_write_trailer,
472
};
473
#endif //CONFIG_MUXERS
474

    
475
AVInputFormat m4v_iformat = {
476
    "m4v",
477
    "raw MPEG4 video format",
478
    0,
479
    NULL /*mpegvideo_probe*/,
480
    video_read_header,
481
    raw_read_partial_packet,
482
    raw_read_close,
483
    .extensions = "m4v", //FIXME remove after writing mpeg4_probe
484
    .value = CODEC_ID_MPEG4,
485
};
486

    
487
#ifdef CONFIG_MUXERS
488
AVOutputFormat m4v_oformat = {
489
    "m4v",
490
    "raw MPEG4 video format",
491
    NULL,
492
    "m4v",
493
    0,
494
    CODEC_ID_NONE,
495
    CODEC_ID_MPEG4,
496
    raw_write_header,
497
    raw_write_packet,
498
    raw_write_trailer,
499
};
500
#endif //CONFIG_MUXERS
501

    
502
AVInputFormat h264_iformat = {
503
    "h264",
504
    "raw H264 video format",
505
    0,
506
    NULL /*mpegvideo_probe*/,
507
    video_read_header,
508
    raw_read_partial_packet,
509
    raw_read_close,
510
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
511
    .value = CODEC_ID_H264,
512
};
513

    
514
#ifdef CONFIG_MUXERS
515
AVOutputFormat h264_oformat = {
516
    "h264",
517
    "raw H264 video format",
518
    NULL,
519
    "h264",
520
    0,
521
    CODEC_ID_NONE,
522
    CODEC_ID_H264,
523
    raw_write_header,
524
    raw_write_packet,
525
    raw_write_trailer,
526
};
527
#endif //CONFIG_MUXERS
528

    
529
AVInputFormat mpegvideo_iformat = {
530
    "mpegvideo",
531
    "MPEG video",
532
    0,
533
    mpegvideo_probe,
534
    video_read_header,
535
    raw_read_partial_packet,
536
    raw_read_close,
537
    .value = CODEC_ID_MPEG1VIDEO,
538
};
539

    
540
#ifdef CONFIG_MUXERS
541
AVOutputFormat mpeg1video_oformat = {
542
    "mpeg1video",
543
    "MPEG video",
544
    "video/x-mpeg",
545
    "mpg,mpeg,m1v",
546
    0,
547
    0,
548
    CODEC_ID_MPEG1VIDEO,
549
    raw_write_header,
550
    raw_write_packet,
551
    raw_write_trailer,
552
};
553
#endif //CONFIG_MUXERS
554

    
555
#ifdef CONFIG_MUXERS
556
AVOutputFormat mpeg2video_oformat = {
557
    "mpeg2video",
558
    "MPEG2 video",
559
    NULL,
560
    "m2v",
561
    0,
562
    0,
563
    CODEC_ID_MPEG2VIDEO,
564
    raw_write_header,
565
    raw_write_packet,
566
    raw_write_trailer,
567
};
568
#endif //CONFIG_MUXERS
569

    
570
AVInputFormat mjpeg_iformat = {
571
    "mjpeg",
572
    "MJPEG video",
573
    0,
574
    NULL,
575
    video_read_header,
576
    raw_read_partial_packet,
577
    raw_read_close,
578
    .extensions = "mjpg,mjpeg",
579
    .value = CODEC_ID_MJPEG,
580
};
581

    
582
AVInputFormat ingenient_iformat = {
583
    "ingenient",
584
    "Ingenient MJPEG",
585
    0,
586
    NULL,
587
    video_read_header,
588
    ingenient_read_packet,
589
    raw_read_close,
590
    .extensions = "cgi", // FIXME
591
    .value = CODEC_ID_MJPEG,
592
};
593

    
594
#ifdef CONFIG_MUXERS
595
AVOutputFormat mjpeg_oformat = {
596
    "mjpeg",
597
    "MJPEG video",
598
    "video/x-mjpeg",
599
    "mjpg,mjpeg",
600
    0,
601
    0,
602
    CODEC_ID_MJPEG,
603
    raw_write_header,
604
    raw_write_packet,
605
    raw_write_trailer,
606
};
607
#endif //CONFIG_MUXERS
608

    
609
/* pcm formats */
610

    
611
#define PCMINPUTDEF(name, long_name, ext, codec) \
612
AVInputFormat pcm_ ## name ## _iformat = {\
613
    #name,\
614
    long_name,\
615
    0,\
616
    NULL,\
617
    raw_read_header,\
618
    raw_read_packet,\
619
    raw_read_close,\
620
    pcm_read_seek,\
621
    .extensions = ext,\
622
    .value = codec,\
623
};
624

    
625
#if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
626

    
627
#define PCMDEF(name, long_name, ext, codec) \
628
    PCMINPUTDEF(name, long_name, ext, codec)
629

    
630
#else
631

    
632
#define PCMDEF(name, long_name, ext, codec) \
633
    PCMINPUTDEF(name, long_name, ext, codec)\
634
\
635
AVOutputFormat pcm_ ## name ## _oformat = {\
636
    #name,\
637
    long_name,\
638
    NULL,\
639
    ext,\
640
    0,\
641
    codec,\
642
    0,\
643
    raw_write_header,\
644
    raw_write_packet,\
645
    raw_write_trailer,\
646
};
647
#endif //CONFIG_MUXERS
648

    
649
#ifdef WORDS_BIGENDIAN
650
#define BE_DEF(s) s
651
#define LE_DEF(s) NULL
652
#else
653
#define BE_DEF(s) NULL
654
#define LE_DEF(s) s
655
#endif
656

    
657

    
658
PCMDEF(s16le, "pcm signed 16 bit little endian format",
659
       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
660

    
661
PCMDEF(s16be, "pcm signed 16 bit big endian format",
662
       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
663

    
664
PCMDEF(u16le, "pcm unsigned 16 bit little endian format",
665
       LE_DEF("uw"), CODEC_ID_PCM_U16LE)
666

    
667
PCMDEF(u16be, "pcm unsigned 16 bit big endian format",
668
       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
669

    
670
PCMDEF(s8, "pcm signed 8 bit format",
671
       "sb", CODEC_ID_PCM_S8)
672

    
673
PCMDEF(u8, "pcm unsigned 8 bit format",
674
       "ub", CODEC_ID_PCM_U8)
675

    
676
PCMDEF(mulaw, "pcm mu law format",
677
       "ul", CODEC_ID_PCM_MULAW)
678

    
679
PCMDEF(alaw, "pcm A law format",
680
       "al", CODEC_ID_PCM_ALAW)
681

    
682
static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
683
{
684
    int packet_size, ret, width, height;
685
    AVStream *st = s->streams[0];
686

    
687
    width = st->codec->width;
688
    height = st->codec->height;
689

    
690
    packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
691
    if (packet_size < 0)
692
        return -1;
693

    
694
    ret= av_get_packet(&s->pb, pkt, packet_size);
695

    
696
    pkt->stream_index = 0;
697
    if (ret != packet_size) {
698
        return AVERROR_IO;
699
    } else {
700
        return 0;
701
    }
702
}
703

    
704
AVInputFormat rawvideo_iformat = {
705
    "rawvideo",
706
    "raw video format",
707
    0,
708
    NULL,
709
    raw_read_header,
710
    rawvideo_read_packet,
711
    raw_read_close,
712
    .extensions = "yuv,cif,qcif",
713
    .value = CODEC_ID_RAWVIDEO,
714
};
715

    
716
#ifdef CONFIG_MUXERS
717
AVOutputFormat rawvideo_oformat = {
718
    "rawvideo",
719
    "raw video format",
720
    NULL,
721
    "yuv",
722
    0,
723
    CODEC_ID_NONE,
724
    CODEC_ID_RAWVIDEO,
725
    raw_write_header,
726
    raw_write_packet,
727
    raw_write_trailer,
728
};
729
#endif //CONFIG_MUXERS
730

    
731
#ifdef CONFIG_MUXERS
732
static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
733
{
734
    return 0;
735
}
736

    
737
AVOutputFormat null_oformat = {
738
    "null",
739
    "null video format",
740
    NULL,
741
    NULL,
742
    0,
743
#ifdef WORDS_BIGENDIAN
744
    CODEC_ID_PCM_S16BE,
745
#else
746
    CODEC_ID_PCM_S16LE,
747
#endif
748
    CODEC_ID_RAWVIDEO,
749
    raw_write_header,
750
    null_write_packet,
751
    raw_write_trailer,
752
    .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE,
753
};
754
#endif //CONFIG_MUXERS
755

    
756
#ifndef CONFIG_MUXERS
757
#define av_register_output_format(format)
758
#endif
759
#ifndef CONFIG_DEMUXERS
760
#define av_register_input_format(format)
761
#endif
762

    
763
int raw_init(void)
764
{
765

    
766
    av_register_input_format(&shorten_iformat);
767

    
768
    av_register_input_format(&ac3_iformat);
769
    av_register_output_format(&ac3_oformat);
770

    
771
    av_register_input_format(&aac_iformat);
772

    
773
    av_register_input_format(&dts_iformat);
774

    
775
    av_register_input_format(&h261_iformat);
776
    av_register_output_format(&h261_oformat);
777

    
778
    av_register_input_format(&h263_iformat);
779
    av_register_output_format(&h263_oformat);
780

    
781
    av_register_input_format(&m4v_iformat);
782
    av_register_output_format(&m4v_oformat);
783

    
784
    av_register_input_format(&h264_iformat);
785
    av_register_output_format(&h264_oformat);
786

    
787
    av_register_input_format(&mpegvideo_iformat);
788
    av_register_output_format(&mpeg1video_oformat);
789

    
790
    av_register_output_format(&mpeg2video_oformat);
791

    
792
    av_register_input_format(&mjpeg_iformat);
793
    av_register_output_format(&mjpeg_oformat);
794

    
795
    av_register_input_format(&ingenient_iformat);
796

    
797
    av_register_input_format(&pcm_s16le_iformat);
798
    av_register_output_format(&pcm_s16le_oformat);
799
    av_register_input_format(&pcm_s16be_iformat);
800
    av_register_output_format(&pcm_s16be_oformat);
801
    av_register_input_format(&pcm_u16le_iformat);
802
    av_register_output_format(&pcm_u16le_oformat);
803
    av_register_input_format(&pcm_u16be_iformat);
804
    av_register_output_format(&pcm_u16be_oformat);
805
    av_register_input_format(&pcm_s8_iformat);
806
    av_register_output_format(&pcm_s8_oformat);
807
    av_register_input_format(&pcm_u8_iformat);
808
    av_register_output_format(&pcm_u8_oformat);
809
    av_register_input_format(&pcm_mulaw_iformat);
810
    av_register_output_format(&pcm_mulaw_oformat);
811
    av_register_input_format(&pcm_alaw_iformat);
812
    av_register_output_format(&pcm_alaw_oformat);
813

    
814
    av_register_input_format(&rawvideo_iformat);
815
    av_register_output_format(&rawvideo_oformat);
816

    
817
    av_register_output_format(&null_oformat);
818
    return 0;
819
}