"Fossies" - the Fresh Open Source Software Archive

Member "ffmpeg-4.0.1/libavformat/aacdec.c" (20 Apr 2018, 5980 Bytes) of package /linux/misc/ffmpeg-4.0.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "aacdec.c" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 3.4.2_vs_4.0.

    1 /*
    2  * raw ADTS AAC demuxer
    3  * Copyright (c) 2008 Michael Niedermayer <michaelni@gmx.at>
    4  * Copyright (c) 2009 Robert Swain ( rob opendot cl )
    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 "libavutil/intreadwrite.h"
   24 #include "avformat.h"
   25 #include "avio_internal.h"
   26 #include "internal.h"
   27 #include "id3v1.h"
   28 #include "id3v2.h"
   29 #include "apetag.h"
   30 
   31 #define ADTS_HEADER_SIZE 7
   32 
   33 static int adts_aac_probe(AVProbeData *p)
   34 {
   35     int max_frames = 0, first_frames = 0;
   36     int fsize, frames;
   37     const uint8_t *buf0 = p->buf;
   38     const uint8_t *buf2;
   39     const uint8_t *buf;
   40     const uint8_t *end = buf0 + p->buf_size - 7;
   41 
   42     buf = buf0;
   43 
   44     for (; buf < end; buf = buf2 + 1) {
   45         buf2 = buf;
   46 
   47         for (frames = 0; buf2 < end; frames++) {
   48             uint32_t header = AV_RB16(buf2);
   49             if ((header & 0xFFF6) != 0xFFF0) {
   50                 if (buf != buf0) {
   51                     // Found something that isn't an ADTS header, starting
   52                     // from a position other than the start of the buffer.
   53                     // Discard the count we've accumulated so far since it
   54                     // probably was a false positive.
   55                     frames = 0;
   56                 }
   57                 break;
   58             }
   59             fsize = (AV_RB32(buf2 + 3) >> 13) & 0x1FFF;
   60             if (fsize < 7)
   61                 break;
   62             fsize = FFMIN(fsize, end - buf2);
   63             buf2 += fsize;
   64         }
   65         max_frames = FFMAX(max_frames, frames);
   66         if (buf == buf0)
   67             first_frames = frames;
   68     }
   69 
   70     if (first_frames >= 3)
   71         return AVPROBE_SCORE_EXTENSION + 1;
   72     else if (max_frames > 100)
   73         return AVPROBE_SCORE_EXTENSION;
   74     else if (max_frames >= 3)
   75         return AVPROBE_SCORE_EXTENSION / 2;
   76     else if (first_frames >= 1)
   77         return 1;
   78     else
   79         return 0;
   80 }
   81 
   82 static int adts_aac_read_header(AVFormatContext *s)
   83 {
   84     AVStream *st;
   85     uint16_t state;
   86 
   87     st = avformat_new_stream(s, NULL);
   88     if (!st)
   89         return AVERROR(ENOMEM);
   90 
   91     st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
   92     st->codecpar->codec_id   = s->iformat->raw_codec_id;
   93     st->need_parsing         = AVSTREAM_PARSE_FULL_RAW;
   94 
   95     ff_id3v1_read(s);
   96     if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
   97         !av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) {
   98         int64_t cur = avio_tell(s->pb);
   99         ff_ape_parse_tag(s);
  100         avio_seek(s->pb, cur, SEEK_SET);
  101     }
  102 
  103     // skip data until the first ADTS frame is found
  104     state = avio_r8(s->pb);
  105     while (!avio_feof(s->pb) && avio_tell(s->pb) < s->probesize) {
  106         state = (state << 8) | avio_r8(s->pb);
  107         if ((state >> 4) != 0xFFF)
  108             continue;
  109         avio_seek(s->pb, -2, SEEK_CUR);
  110         break;
  111     }
  112     if ((state >> 4) != 0xFFF)
  113         return AVERROR_INVALIDDATA;
  114 
  115     // LCM of all possible ADTS sample rates
  116     avpriv_set_pts_info(st, 64, 1, 28224000);
  117 
  118     return 0;
  119 }
  120 
  121 static int handle_id3(AVFormatContext *s, AVPacket *pkt)
  122 {
  123     AVDictionary *metadata = NULL;
  124     AVIOContext ioctx;
  125     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
  126     int ret;
  127 
  128     ret = av_append_packet(s->pb, pkt, ff_id3v2_tag_len(pkt->data) - pkt->size);
  129     if (ret < 0) {
  130         av_packet_unref(pkt);
  131         return ret;
  132     }
  133 
  134     ffio_init_context(&ioctx, pkt->data, pkt->size, 0, NULL, NULL, NULL, NULL);
  135     ff_id3v2_read_dict(&ioctx, &metadata, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
  136     if ((ret = ff_id3v2_parse_priv_dict(&metadata, &id3v2_extra_meta)) < 0)
  137         goto error;
  138 
  139     if (metadata) {
  140         if ((ret = av_dict_copy(&s->metadata, metadata, 0)) < 0)
  141             goto error;
  142         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
  143     }
  144 
  145 error:
  146     av_packet_unref(pkt);
  147     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
  148     av_dict_free(&metadata);
  149 
  150     return ret;
  151 }
  152 
  153 static int adts_aac_read_packet(AVFormatContext *s, AVPacket *pkt)
  154 {
  155     int ret, fsize;
  156 
  157     // Parse all the ID3 headers between frames
  158     while (1) {
  159         ret = av_get_packet(s->pb, pkt, FFMAX(ID3v2_HEADER_SIZE, ADTS_HEADER_SIZE));
  160         if (ret >= ID3v2_HEADER_SIZE && ff_id3v2_match(pkt->data, ID3v2_DEFAULT_MAGIC)) {
  161             if ((ret = handle_id3(s, pkt)) >= 0) {
  162                 continue;
  163             }
  164         }
  165         break;
  166     }
  167 
  168     if (ret < 0)
  169         return ret;
  170 
  171     if (ret < ADTS_HEADER_SIZE) {
  172         av_packet_unref(pkt);
  173         return AVERROR(EIO);
  174     }
  175 
  176     if ((AV_RB16(pkt->data) >> 4) != 0xfff) {
  177         av_packet_unref(pkt);
  178         return AVERROR_INVALIDDATA;
  179     }
  180 
  181     fsize = (AV_RB32(pkt->data + 3) >> 13) & 0x1FFF;
  182     if (fsize < ADTS_HEADER_SIZE) {
  183         av_packet_unref(pkt);
  184         return AVERROR_INVALIDDATA;
  185     }
  186 
  187     ret = av_append_packet(s->pb, pkt, fsize - pkt->size);
  188     if (ret < 0)
  189         av_packet_unref(pkt);
  190 
  191     return ret;
  192 }
  193 
  194 AVInputFormat ff_aac_demuxer = {
  195     .name         = "aac",
  196     .long_name    = NULL_IF_CONFIG_SMALL("raw ADTS AAC (Advanced Audio Coding)"),
  197     .read_probe   = adts_aac_probe,
  198     .read_header  = adts_aac_read_header,
  199     .read_packet  = adts_aac_read_packet,
  200     .flags        = AVFMT_GENERIC_INDEX,
  201     .extensions   = "aac",
  202     .mime_type    = "audio/aac,audio/aacp,audio/x-aac",
  203     .raw_codec_id = AV_CODEC_ID_AAC,
  204 };