Line data    Source code

       1             : /*
       2             :  * SBC parser
       3             :  *
       4             :  * Copyright (C) 2017  Aurelien Jacobs <aurel@gnuage.org>
       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 "sbc.h"
      24             : #include "parser.h"
      25             : 
      26             : typedef struct SBCParseContext {
      27             :     ParseContext pc;
      28             :     uint8_t header[3];
      29             :     int header_size;
      30             :     int buffered_size;
      31             : } SBCParseContext;
      32             : 
      33           0 : static int sbc_parse_header(AVCodecParserContext *s, AVCodecContext *avctx,
      34             :                             const uint8_t *data, size_t len)
      35             : {
      36             :     static const int sample_rates[4] = { 16000, 32000, 44100, 48000 };
      37             :     int sr, blocks, mode, subbands, bitpool, channels, joint;
      38             :     int length;
      39             : 
      40           0 :     if (len < 3)
      41           0 :         return -1;
      42             : 
      43           0 :     if (data[0] == MSBC_SYNCWORD && data[1] == 0 && data[2] == 0) {
      44           0 :         avctx->channels = 1;
      45           0 :         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
      46           0 :         avctx->sample_rate = 16000;
      47           0 :         avctx->frame_size = 120;
      48           0 :         s->duration = avctx->frame_size;
      49           0 :         return 57;
      50             :     }
      51             : 
      52           0 :     if (data[0] != SBC_SYNCWORD)
      53           0 :         return -2;
      54             : 
      55           0 :     sr       =   (data[1] >> 6) & 0x03;
      56           0 :     blocks   = (((data[1] >> 4) & 0x03) + 1) << 2;
      57           0 :     mode     =   (data[1] >> 2) & 0x03;
      58           0 :     subbands = (((data[1] >> 0) & 0x01) + 1) << 2;
      59           0 :     bitpool  = data[2];
      60             : 
      61           0 :     channels = mode == SBC_MODE_MONO ? 1 : 2;
      62           0 :     joint    = mode == SBC_MODE_JOINT_STEREO;
      63             : 
      64           0 :     length = 4 + (subbands * channels) / 2
      65           0 :              + ((((mode == SBC_MODE_DUAL_CHANNEL) + 1) * blocks * bitpool
      66           0 :                  + (joint * subbands)) + 7) / 8;
      67             : 
      68           0 :     avctx->channels = channels;
      69           0 :     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
      70           0 :     avctx->sample_rate = sample_rates[sr];
      71           0 :     avctx->frame_size = subbands * blocks;
      72           0 :     s->duration = avctx->frame_size;
      73           0 :     return length;
      74             : }
      75             : 
      76           0 : static int sbc_parse(AVCodecParserContext *s, AVCodecContext *avctx,
      77             :                      const uint8_t **poutbuf, int *poutbuf_size,
      78             :                      const uint8_t *buf, int buf_size)
      79             : {
      80           0 :     SBCParseContext *pc = s->priv_data;
      81             :     int next;
      82             : 
      83           0 :     if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
      84           0 :         next = buf_size;
      85             :     } else {
      86           0 :         if (pc->header_size) {
      87           0 :             memcpy(pc->header + pc->header_size, buf,
      88           0 :                    sizeof(pc->header) - pc->header_size);
      89           0 :             next = sbc_parse_header(s, avctx, pc->header, sizeof(pc->header))
      90           0 :                  - pc->buffered_size;
      91           0 :             pc->header_size = 0;
      92             :         } else {
      93           0 :             next = sbc_parse_header(s, avctx, buf, buf_size);
      94           0 :             if (next >= buf_size)
      95           0 :                 next = -1;
      96             :         }
      97             : 
      98           0 :         if (next < 0) {
      99           0 :             pc->header_size = FFMIN(sizeof(pc->header), buf_size);
     100           0 :             memcpy(pc->header, buf, pc->header_size);
     101           0 :             pc->buffered_size = buf_size;
     102           0 :             next = END_NOT_FOUND;
     103             :         }
     104             : 
     105           0 :         if (ff_combine_frame(&pc->pc, next, &buf, &buf_size) < 0) {
     106           0 :             *poutbuf      = NULL;
     107           0 :             *poutbuf_size = 0;
     108           0 :             return buf_size;
     109             :         }
     110             :     }
     111             : 
     112           0 :     *poutbuf      = buf;
     113           0 :     *poutbuf_size = buf_size;
     114           0 :     return next;
     115             : }
     116             : 
     117             : AVCodecParser ff_sbc_parser = {
     118             :     .codec_ids      = { AV_CODEC_ID_SBC },
     119             :     .priv_data_size = sizeof(SBCParseContext),
     120             :     .parser_parse   = sbc_parse,
     121             :     .parser_close   = ff_parse_close,
     122             : };