In mpegts muxer, write adts header if aac bitstream does not contain it
[ffmpeg.git] / libavformat / adtsenc.c
1 /*
2  * ADTS muxer.
3  * Copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@smartjog.com>
4  *                    Mans Rullgard <mans@mansr.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * 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  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * 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 #include "libavcodec/get_bits.h"
24 #include "libavcodec/put_bits.h"
25 #include "libavcodec/avcodec.h"
26 #include "avformat.h"
27 #include "adts.h"
28
29 int ff_adts_decode_extradata(AVFormatContext *s, ADTSContext *adts, uint8_t *buf, int size)
30 {
31     GetBitContext gb;
32     PutBitContext pb;
33
34     init_get_bits(&gb, buf, size * 8);
35     adts->objecttype = get_bits(&gb, 5) - 1;
36     adts->sample_rate_index = get_bits(&gb, 4);
37     adts->channel_conf = get_bits(&gb, 4);
38
39     if (adts->objecttype > 3U) {
40         av_log(s, AV_LOG_ERROR, "MPEG-4 AOT %d is not allowed in ADTS\n", adts->objecttype+1);
41         return -1;
42     }
43     if (adts->sample_rate_index == 15) {
44         av_log(s, AV_LOG_ERROR, "Escape sample rate index illegal in ADTS\n");
45         return -1;
46     }
47     if (get_bits(&gb, 1)) {
48         av_log(s, AV_LOG_ERROR, "960/120 MDCT window is not allowed in ADTS\n");
49         return -1;
50     }
51     if (get_bits(&gb, 1)) {
52         av_log(s, AV_LOG_ERROR, "Scalable configurations are not allowed in ADTS\n");
53         return -1;
54     }
55     if (get_bits(&gb, 1)) {
56         av_log_missing_feature(s, "Signaled SBR or PS", 0);
57         return -1;
58     }
59     if (!adts->channel_conf) {
60         init_put_bits(&pb, adts->pce_data, MAX_PCE_SIZE);
61
62         put_bits(&pb, 3, 5); //ID_PCE
63         adts->pce_size = (ff_copy_pce_data(&pb, &gb) + 3) / 8;
64         flush_put_bits(&pb);
65     }
66
67     adts->write_adts = 1;
68
69     return 0;
70 }
71
72 static int adts_write_header(AVFormatContext *s)
73 {
74     ADTSContext *adts = s->priv_data;
75     AVCodecContext *avc = s->streams[0]->codec;
76
77     if(avc->extradata_size > 0 &&
78             ff_adts_decode_extradata(s, adts, avc->extradata, avc->extradata_size) < 0)
79         return -1;
80
81     return 0;
82 }
83
84 int ff_adts_write_frame_header(ADTSContext *ctx,
85                                uint8_t *buf, int size, int pce_size)
86 {
87     PutBitContext pb;
88
89     init_put_bits(&pb, buf, ADTS_HEADER_SIZE);
90
91     /* adts_fixed_header */
92     put_bits(&pb, 12, 0xfff);   /* syncword */
93     put_bits(&pb, 1, 0);        /* ID */
94     put_bits(&pb, 2, 0);        /* layer */
95     put_bits(&pb, 1, 1);        /* protection_absent */
96     put_bits(&pb, 2, ctx->objecttype); /* profile_objecttype */
97     put_bits(&pb, 4, ctx->sample_rate_index);
98     put_bits(&pb, 1, 0);        /* private_bit */
99     put_bits(&pb, 3, ctx->channel_conf); /* channel_configuration */
100     put_bits(&pb, 1, 0);        /* original_copy */
101     put_bits(&pb, 1, 0);        /* home */
102
103     /* adts_variable_header */
104     put_bits(&pb, 1, 0);        /* copyright_identification_bit */
105     put_bits(&pb, 1, 0);        /* copyright_identification_start */
106     put_bits(&pb, 13, ADTS_HEADER_SIZE + size + pce_size); /* aac_frame_length */
107     put_bits(&pb, 11, 0x7ff);   /* adts_buffer_fullness */
108     put_bits(&pb, 2, 0);        /* number_of_raw_data_blocks_in_frame */
109
110     flush_put_bits(&pb);
111
112     return 0;
113 }
114
115 static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
116 {
117     ADTSContext *adts = s->priv_data;
118     ByteIOContext *pb = s->pb;
119     uint8_t buf[ADTS_HEADER_SIZE];
120
121     if (!pkt->size)
122         return 0;
123     if(adts->write_adts) {
124         ff_adts_write_frame_header(adts, buf, pkt->size, adts->pce_size);
125         put_buffer(pb, buf, ADTS_HEADER_SIZE);
126         if(adts->pce_size) {
127             put_buffer(pb, adts->pce_data, adts->pce_size);
128             adts->pce_size = 0;
129         }
130     }
131     put_buffer(pb, pkt->data, pkt->size);
132     put_flush_packet(pb);
133
134     return 0;
135 }
136
137 AVOutputFormat adts_muxer = {
138     "adts",
139     NULL_IF_CONFIG_SMALL("ADTS AAC"),
140     "audio/aac",
141     "aac,adts",
142     sizeof(ADTSContext),
143     CODEC_ID_AAC,
144     CODEC_ID_NONE,
145     adts_write_header,
146     adts_write_packet,
147 };