stereo3d: Support view type for frame sequence type
[ffmpeg.git] / libavcodec / flac.c
index 32b28d0..5062c1e 100644 (file)
 #include "libavutil/channel_layout.h"
 #include "libavutil/crc.h"
 #include "libavutil/log.h"
+
+#include "bitstream.h"
 #include "bytestream.h"
-#include "get_bits.h"
 #include "flac.h"
 #include "flacdata.h"
 
 static const int8_t sample_size_table[] = { 0, 8, 12, 0, 16, 20, 24, 0 };
 
-static const int64_t flac_channel_layouts[6] = {
+static const uint64_t flac_channel_layouts[8] = {
     AV_CH_LAYOUT_MONO,
     AV_CH_LAYOUT_STEREO,
     AV_CH_LAYOUT_SURROUND,
     AV_CH_LAYOUT_QUAD,
     AV_CH_LAYOUT_5POINT0,
-    AV_CH_LAYOUT_5POINT1
+    AV_CH_LAYOUT_5POINT1,
+    AV_CH_LAYOUT_6POINT1,
+    AV_CH_LAYOUT_7POINT1
 };
 
-static int64_t get_utf8(GetBitContext *gb)
+static int64_t get_utf8(BitstreamContext *bc)
 {
     int64_t val;
-    GET_UTF8(val, get_bits(gb, 8), return -1;)
+    GET_UTF8(val, bitstream_read(bc, 8), return -1;)
     return val;
 }
 
-int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
+int ff_flac_decode_frame_header(AVCodecContext *avctx, BitstreamContext *bc,
                                 FLACFrameInfo *fi, int log_level_offset)
 {
     int bs_code, sr_code, bps_code;
 
     /* frame sync code */
-    if ((get_bits(gb, 15) & 0x7FFF) != 0x7FFC) {
+    if ((bitstream_read(bc, 15) & 0x7FFF) != 0x7FFC) {
         av_log(avctx, AV_LOG_ERROR + log_level_offset, "invalid sync code\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     /* variable block size stream code */
-    fi->is_var_size = get_bits1(gb);
+    fi->is_var_size = bitstream_read_bit(bc);
 
     /* block size and sample rate codes */
-    bs_code = get_bits(gb, 4);
-    sr_code = get_bits(gb, 4);
+    bs_code = bitstream_read(bc, 4);
+    sr_code = bitstream_read(bc, 4);
 
     /* channels and decorrelation */
-    fi->ch_mode = get_bits(gb, 4);
+    fi->ch_mode = bitstream_read(bc, 4);
     if (fi->ch_mode < FLAC_MAX_CHANNELS) {
         fi->channels = fi->ch_mode + 1;
         fi->ch_mode = FLAC_CHMODE_INDEPENDENT;
@@ -74,43 +77,43 @@ int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
     } else {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "invalid channel mode: %d\n", fi->ch_mode);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     /* bits per sample */
-    bps_code = get_bits(gb, 3);
+    bps_code = bitstream_read(bc, 3);
     if (bps_code == 3 || bps_code == 7) {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "invalid sample size code (%d)\n",
                bps_code);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
     fi->bps = sample_size_table[bps_code];
 
     /* reserved bit */
-    if (get_bits1(gb)) {
+    if (bitstream_read_bit(bc)) {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "broken stream, invalid padding\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     /* sample or frame count */
-    fi->frame_or_sample_num = get_utf8(gb);
+    fi->frame_or_sample_num = get_utf8(bc);
     if (fi->frame_or_sample_num < 0) {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "sample/frame number invalid; utf8 fscked\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     /* blocksize */
     if (bs_code == 0) {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "reserved blocksize code: 0\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     } else if (bs_code == 6) {
-        fi->blocksize = get_bits(gb, 8) + 1;
+        fi->blocksize = bitstream_read(bc, 8) + 1;
     } else if (bs_code == 7) {
-        fi->blocksize = get_bits(gb, 16) + 1;
+        fi->blocksize = bitstream_read(bc, 16) + 1;
     } else {
         fi->blocksize = ff_flac_blocksize_table[bs_code];
     }
@@ -119,25 +122,25 @@ int ff_flac_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb,
     if (sr_code < 12) {
         fi->samplerate = ff_flac_sample_rate_table[sr_code];
     } else if (sr_code == 12) {
-        fi->samplerate = get_bits(gb, 8) * 1000;
+        fi->samplerate = bitstream_read(bc, 8) * 1000;
     } else if (sr_code == 13) {
-        fi->samplerate = get_bits(gb, 16);
+        fi->samplerate = bitstream_read(bc, 16);
     } else if (sr_code == 14) {
-        fi->samplerate = get_bits(gb, 16) * 10;
+        fi->samplerate = bitstream_read(bc, 16) * 10;
     } else {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "illegal sample rate code %d\n",
                sr_code);
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     /* header CRC-8 check */
-    skip_bits(gb, 8);
-    if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer,
-               get_bits_count(gb)/8)) {
+    bitstream_skip(bc, 8);
+    if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, bc->buffer,
+               bitstream_tell(bc) / 8)) {
         av_log(avctx, AV_LOG_ERROR + log_level_offset,
                "header crc mismatch\n");
-        return -1;
+        return AVERROR_INVALIDDATA;
     }
 
     return 0;
@@ -164,7 +167,7 @@ int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
     return count;
 }
 
-int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
+int ff_flac_is_extradata_valid(AVCodecContext *avctx,
                                enum FLACExtradataFormat *format,
                                uint8_t **streaminfo_start)
 {
@@ -199,47 +202,52 @@ void ff_flac_set_channel_layout(AVCodecContext *avctx)
         avctx->channel_layout = 0;
 }
 
-void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
+void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
                               const uint8_t *buffer)
 {
-    GetBitContext gb;
-    init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
+    BitstreamContext bc;
+    bitstream_init8(&bc, buffer, FLAC_STREAMINFO_SIZE);
 
-    skip_bits(&gb, 16); /* skip min blocksize */
-    s->max_blocksize = get_bits(&gb, 16);
+    bitstream_skip(&bc, 16); /* skip min blocksize */
+    s->max_blocksize = bitstream_read(&bc, 16);
     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
                s->max_blocksize);
         s->max_blocksize = 16;
     }
 
-    skip_bits(&gb, 24); /* skip min frame size */
-    s->max_framesize = get_bits_long(&gb, 24);
-
-    s->samplerate = get_bits_long(&gb, 20);
-    s->channels = get_bits(&gb, 3) + 1;
-    s->bps = get_bits(&gb, 5) + 1;
+    bitstream_skip(&bc, 24); /* skip min frame size */
+    s->max_framesize = bitstream_read(&bc, 24);
+    s->samplerate    = bitstream_read(&bc, 20);
+    s->channels      = bitstream_read(&bc, 3) + 1;
+    s->bps           = bitstream_read(&bc, 5) + 1;
 
     avctx->channels = s->channels;
     avctx->sample_rate = s->samplerate;
     avctx->bits_per_raw_sample = s->bps;
-    ff_flac_set_channel_layout(avctx);
 
-    s->samples  = get_bits_long(&gb, 32) << 4;
-    s->samples |= get_bits(&gb, 4);
+    if (!avctx->channel_layout ||
+        av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels)
+        ff_flac_set_channel_layout(avctx);
 
-    skip_bits_long(&gb, 64); /* md5 sum */
-    skip_bits_long(&gb, 64); /* md5 sum */
+    s->samples  = bitstream_read(&bc, 32) << 4;
+    s->samples |= bitstream_read(&bc, 4);
+
+    bitstream_skip(&bc, 64); /* md5 sum */
+    bitstream_skip(&bc, 64); /* md5 sum */
 }
 
-void avpriv_flac_parse_block_header(const uint8_t *block_header,
-                                int *last, int *type, int *size)
+#if LIBAVCODEC_VERSION_MAJOR < 57
+void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
+                              const uint8_t *buffer)
+{
+    ff_flac_parse_streaminfo(avctx, s, buffer);
+}
+
+int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
+                               enum FLACExtradataFormat *format,
+                               uint8_t **streaminfo_start)
 {
-    int tmp = bytestream_get_byte(&block_header);
-    if (last)
-        *last = tmp & 0x80;
-    if (type)
-        *type = tmp & 0x7F;
-    if (size)
-        *size = bytestream_get_be24(&block_header);
+    return ff_flac_is_extradata_valid(avctx, format, streaminfo_start);
 }
+#endif