git.sesse.net Git - ffmpeg/blob - libavcodec/bitstream_filter.c

   1 /*
   2  * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg 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.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg 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 FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "avcodec.h"
  22 #include "mpegaudio.h"
  23
  24 AVBitStreamFilter *first_bitstream_filter= NULL;
  25
  26 void av_register_bitstream_filter(AVBitStreamFilter *bsf){
  27     bsf->next = first_bitstream_filter;
  28     first_bitstream_filter= bsf;
  29 }
  30
  31 AVBitStreamFilterContext *av_bitstream_filter_init(const char *name){
  32     AVBitStreamFilter *bsf= first_bitstream_filter;
  33
  34     while(bsf){
  35         if(!strcmp(name, bsf->name)){
  36             AVBitStreamFilterContext *bsfc= av_mallocz(sizeof(AVBitStreamFilterContext));
  37             bsfc->filter= bsf;
  38             bsfc->priv_data= av_mallocz(bsf->priv_data_size);
  39             return bsfc;
  40         }
  41         bsf= bsf->next;
  42     }
  43     return NULL;
  44 }
  45
  46 void av_bitstream_filter_close(AVBitStreamFilterContext *bsfc){
  47     av_freep(&bsfc->priv_data);
  48     av_parser_close(bsfc->parser);
  49     av_free(bsfc);
  50 }
  51
  52 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
  53                                AVCodecContext *avctx, const char *args,
  54                      uint8_t **poutbuf, int *poutbuf_size,
  55                      const uint8_t *buf, int buf_size, int keyframe){
  56     *poutbuf= (uint8_t *) buf;
  57     *poutbuf_size= buf_size;
  58     return bsfc->filter->filter(bsfc, avctx, args, poutbuf, poutbuf_size, buf, buf_size, keyframe);
  59 }
  60
  61 static int dump_extradata(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
  62                      uint8_t **poutbuf, int *poutbuf_size,
  63                      const uint8_t *buf, int buf_size, int keyframe){
  64     int cmd= args ? *args : 0;
  65     /* cast to avoid warning about discarding qualifiers */
  66     if(avctx->extradata){
  67         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER) && cmd=='a')
  68            ||(keyframe && (cmd=='k' || !cmd))
  69            ||(cmd=='e')
  70             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
  71             int size= buf_size + avctx->extradata_size;
  72             *poutbuf_size= size;
  73             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
  74
  75             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
  76             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
  77             return 1;
  78         }
  79     }
  80     return 0;
  81 }
  82
  83 static int remove_extradata(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
  84                      uint8_t **poutbuf, int *poutbuf_size,
  85                      const uint8_t *buf, int buf_size, int keyframe){
  86     int cmd= args ? *args : 0;
  87     AVCodecParserContext *s;
  88
  89     if(!bsfc->parser){
  90         bsfc->parser= av_parser_init(avctx->codec_id);
  91     }
  92     s= bsfc->parser;
  93
  94     if(s && s->parser->split){
  95         if(  (((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)) && cmd=='a')
  96            ||(!keyframe && cmd=='k')
  97            ||(cmd=='e' || !cmd)
  98           ){
  99             int i= s->parser->split(avctx, buf, buf_size);
 100             buf += i;
 101             buf_size -= i;
 102         }
 103     }
 104     *poutbuf= (uint8_t *) buf;
 105     *poutbuf_size= buf_size;
 106
 107     return 0;
 108 }
 109
 110 static int noise(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
 111                      uint8_t **poutbuf, int *poutbuf_size,
 112                      const uint8_t *buf, int buf_size, int keyframe){
 113     int amount= args ? atoi(args) : 10000;
 114     unsigned int *state= bsfc->priv_data;
 115     int i;
 116
 117     *poutbuf= av_malloc(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 118
 119     memcpy(*poutbuf, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 120     for(i=0; i<buf_size; i++){
 121         (*state) += (*poutbuf)[i] + 1;
 122         if(*state % amount == 0)
 123             (*poutbuf)[i] = *state;
 124     }
 125     return 1;
 126 }
 127
 128 #define MP3_MASK 0xFFFE0CCF
 129
 130 static int mp3_header_compress(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
 131                      uint8_t **poutbuf, int *poutbuf_size,
 132                      const uint8_t *buf, int buf_size, int keyframe){
 133     uint32_t header, extraheader;
 134     int mode_extension, header_size;
 135
 136     if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
 137         av_log(avctx, AV_LOG_ERROR, "not standards compliant\n");
 138         return -1;
 139     }
 140
 141     header = BE_32(buf);
 142     mode_extension= (header>>4)&3;
 143
 144     if(ff_mpa_check_header(header) < 0 || (header&0x60000) != 0x20000){
 145 output_unchanged:
 146         *poutbuf= (uint8_t *) buf;
 147         *poutbuf_size= buf_size;
 148
 149         av_log(avctx, AV_LOG_INFO, "cannot compress %08X\n", header);
 150         return 0;
 151     }
 152
 153     if(avctx->extradata_size == 0){
 154         avctx->extradata_size=15;
 155         avctx->extradata= av_malloc(avctx->extradata_size);
 156         strcpy(avctx->extradata, "FFCMP3 0.0");
 157         memcpy(avctx->extradata+11, buf, 4);
 158     }
 159     if(avctx->extradata_size != 15){
 160         av_log(avctx, AV_LOG_ERROR, "Extradata invalid\n");
 161         return -1;
 162     }
 163     extraheader = BE_32(avctx->extradata+11);
 164     if((extraheader&MP3_MASK) != (header&MP3_MASK))
 165         goto output_unchanged;
 166
 167     header_size= (header&0x10000) ? 4 : 6;
 168
 169     *poutbuf_size= buf_size - header_size;
 170     *poutbuf= av_malloc(buf_size - header_size + FF_INPUT_BUFFER_PADDING_SIZE);
 171     memcpy(*poutbuf, buf + header_size, buf_size - header_size + FF_INPUT_BUFFER_PADDING_SIZE);
 172
 173     if(avctx->channels==2){
 174         if((header & (3<<19)) != 3<<19){
 175             (*poutbuf)[1] &= 0x3F;
 176             (*poutbuf)[1] |= mode_extension<<6;
 177             FFSWAP(int, (*poutbuf)[1], (*poutbuf)[2]);
 178         }else{
 179             (*poutbuf)[1] &= 0x8F;
 180             (*poutbuf)[1] |= mode_extension<<4;
 181         }
 182     }
 183
 184     return 1;
 185 }
 186
 187 static int mp3_header_decompress(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
 188                      uint8_t **poutbuf, int *poutbuf_size,
 189                      const uint8_t *buf, int buf_size, int keyframe){
 190     uint32_t header;
 191     int sample_rate= avctx->sample_rate;
 192     int sample_rate_index=0;
 193     int lsf, mpeg25, bitrate_index, frame_size;
 194
 195     header = BE_32(buf);
 196     if(ff_mpa_check_header(header) >= 0){
 197         *poutbuf= (uint8_t *) buf;
 198         *poutbuf_size= buf_size;
 199
 200         return 0;
 201     }
 202
 203     if(avctx->extradata_size != 15 || strcmp(avctx->extradata, "FFCMP3 0.0")){
 204         av_log(avctx, AV_LOG_ERROR, "Extradata invalid %d\n", avctx->extradata_size);
 205         return -1;
 206     }
 207
 208     header= BE_32(avctx->extradata+11) & MP3_MASK;
 209
 210     lsf     = sample_rate < (24000+32000)/2;
 211     mpeg25  = sample_rate < (12000+16000)/2;
 212     sample_rate_index= (header>>10)&3;
 213     sample_rate= mpa_freq_tab[sample_rate_index] >> (lsf + mpeg25); //in case sample rate is a little off
 214
 215     for(bitrate_index=2; bitrate_index<30; bitrate_index++){
 216         frame_size = mpa_bitrate_tab[lsf][2][bitrate_index>>1];
 217         frame_size = (frame_size * 144000) / (sample_rate << lsf) + (bitrate_index&1);
 218         if(frame_size == buf_size + 4)
 219             break;
 220         if(frame_size == buf_size + 6)
 221             break;
 222     }
 223     if(bitrate_index == 30){
 224         av_log(avctx, AV_LOG_ERROR, "couldnt find bitrate_index\n");
 225         return -1;
 226     }
 227
 228     header |= (bitrate_index&1)<<9;
 229     header |= (bitrate_index>>1)<<12;
 230     header |= (frame_size == buf_size + 4)<<16; //FIXME actually set a correct crc instead of 0
 231
 232     *poutbuf_size= frame_size;
 233     *poutbuf= av_malloc(frame_size + FF_INPUT_BUFFER_PADDING_SIZE);
 234     memcpy(*poutbuf + frame_size - buf_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 235
 236     if(avctx->channels==2){
 237         uint8_t *p= *poutbuf + frame_size - buf_size;
 238         if(lsf){
 239             FFSWAP(int, p[1], p[2]);
 240             header |= (p[1] & 0xC0)>>2;
 241             p[1] &= 0x3F;
 242         }else{
 243             header |= p[1] & 0x30;
 244             p[1] &= 0xCF;
 245         }
 246     }
 247
 248     (*poutbuf)[0]= header>>24;
 249     (*poutbuf)[1]= header>>16;
 250     (*poutbuf)[2]= header>> 8;
 251     (*poutbuf)[3]= header    ;
 252
 253     return 1;
 254 }
 255
 256 AVBitStreamFilter dump_extradata_bsf={
 257     "dump_extra",
 258     0,
 259     dump_extradata,
 260 };
 261
 262 AVBitStreamFilter remove_extradata_bsf={
 263     "remove_extra",
 264     0,
 265     remove_extradata,
 266 };
 267
 268 AVBitStreamFilter noise_bsf={
 269     "noise",
 270     sizeof(int),
 271     noise,
 272 };
 273
 274 AVBitStreamFilter mp3_header_compress_bsf={
 275     "mp3comp",
 276     0,
 277     mp3_header_compress,
 278 };
 279
 280 AVBitStreamFilter mp3_header_decompress_bsf={
 281     "mp3decomp",
 282     0,
 283     mp3_header_decompress,
 284 };