source: trunk/bitstream_info.c @ 1329

Revision 1329, 29.7 KB checked in by gbooker, 4 years ago (diff)

Was incorrectly counting number of null characters instead of number of consecutive null characters.
Refs #223

Line 
1/*
2 * bitstream_info.h
3 * Created by Graham Booker on 1/6/07.
4 *
5 * This file is part of Perian.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "bitstream_info.h"
23
24#include <AudioToolbox/AudioToolbox.h>
25#include <QuickTime/QuickTime.h>
26
27#import "ac3tab.h"
28#import "CommonUtils.h"
29//ffmpeg's struct Picture conflicts with QuickDraw's
30#define Picture MPEGPICTURE
31
32#include "avcodec.h"
33
34#include "bswap.h"
35#include "libavutil/intmath.h"
36#include "libavutil/internal.h"
37#include "mpegvideo.h"
38#include "parser.h"
39#include "golomb.h"
40#include "mpeg4video.h"
41#include "mpeg4video_parser.h"
42#include "Codecprintf.h"
43
44#include "CodecIDs.h"
45
46#undef malloc
47#undef free
48
49static const int nfchans_tbl[8] = { 2, 1, 2, 3, 3, 4, 4, 5 };
50static const int ac3_layout_no_lfe[8] = {
51        kAudioChannelLayoutTag_Stereo,
52        kAudioChannelLayoutTag_Mono,
53        kAudioChannelLayoutTag_Stereo,
54        kAudioChannelLayoutTag_ITU_3_0,
55        kAudioChannelLayoutTag_ITU_2_1,
56        kAudioChannelLayoutTag_ITU_3_1,
57        kAudioChannelLayoutTag_ITU_2_2,
58        kAudioChannelLayoutTag_ITU_3_2};
59
60static const int ac3_layout_lfe[8] = {
61        kAudioChannelLayoutTag_DVD_4,
62        kAudioChannelLayoutTag_Mono,  //No layout for this, hopefully we never have it
63        kAudioChannelLayoutTag_DVD_4,
64        kAudioChannelLayoutTag_DVD_10,
65        kAudioChannelLayoutTag_DVD_5,
66        kAudioChannelLayoutTag_DVD_11,
67        kAudioChannelLayoutTag_DVD_6,
68        kAudioChannelLayoutTag_ITU_3_2_1};
69
70static const uint16_t ac3_freqs[3] = { 48000, 44100, 32000 };
71static const uint16_t ac3_bitratetab[] = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640};
72static const uint8_t ac3_halfrate[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3};
73
74/* From: http://svn.mplayerhq.hu/ac3/ (LGPL)
75 * Synchronize to ac3 bitstream.
76 * This function searches for the syncword '0xb77'.
77 *
78 * @param buf Pointer to "probable" ac3 bitstream buffer
79 * @param buf_size Size of buffer
80 * @return Returns the position where syncword is found, -1 if no syncword is found
81 */
82static int ac3_synchronize(uint8_t *buf, int buf_size)
83{
84    int i;
85       
86    for (i = 0; i < buf_size - 1; i++)
87        if (buf[i] == 0x0b && buf[i + 1] == 0x77)
88            return i;
89       
90    return -1;
91}
92
93/* A lot of this was stolen from: http://svn.mplayerhq.hu/ac3/ (LGPL)
94 * Fill info from an ac3 stream
95 *
96 * @param asdb Pointer to the AudioStreamBasicDescription to fill
97 * @param acl Pointer to the AudioChannelLayout to fill
98 * @param buffer Pointer to the buffer data to scan
99 * @param buff_size Size of the buffer
100 * @return 1 if successfull, 0 otherwise
101 */
102
103int parse_ac3_bitstream(AudioStreamBasicDescription *asbd, AudioChannelLayout *acl, uint8_t *buffer, int buff_size)
104{
105        int offset = ac3_synchronize(buffer, buff_size);
106        if(offset == -1)
107                return 0;
108       
109        if(buff_size < offset + 7)
110                return 0;
111       
112        uint8_t fscod_and_frmsizecod = buffer[offset + 4];
113       
114        uint8_t fscod = fscod_and_frmsizecod >> 6;
115        uint8_t frmsizecod = fscod_and_frmsizecod & 0x3f;
116        if(frmsizecod >= 38)
117                return 0;
118       
119        uint8_t bsid = buffer[offset + 5] >> 3;
120        if(bsid >= 0x12)
121                return 0;
122       
123        uint8_t acmod = buffer[offset + 6] >> 5;
124        uint8_t shift = 4;
125        if(acmod & 0x01 && acmod != 0x01)
126                shift -= 2;
127        if(acmod & 0x04)
128                shift -= 2;
129        if(acmod == 0x02)
130                shift -= 2;
131        uint8_t lfe = (buffer[offset + 6] >> shift) & 0x01;
132       
133        /* This is a valid frame!!! */
134        uint16_t bitrate = ac3_bitratetab[frmsizecod >> 1];
135        uint8_t half = ac3_halfrate[bsid];
136        int sample_rate = ac3_freqs[fscod] >> half;
137        int framesize = 0;
138        switch (fscod) {
139                case 0:
140                        framesize = 4 * bitrate;
141                        break;
142                case 1:
143                        framesize = (320 * bitrate / 147 + (frmsizecod & 1 ? 1 : 0)) * 2;
144                        break;
145                case 2:
146                        framesize = 6 * bitrate;
147                        break;
148                default:
149                        break;
150        }
151       
152        shift = 0;
153        if(bsid > 8)
154                shift = bsid - 8;
155       
156        /* Setup the AudioStreamBasicDescription and AudioChannelLayout */
157        memset(asbd, 0, sizeof(AudioStreamBasicDescription));
158        asbd->mSampleRate = sample_rate >> shift;
159        asbd->mFormatID = kAudioFormatAC3MS;
160        asbd->mChannelsPerFrame = nfchans_tbl[acmod] + lfe;
161       
162        memset(acl, 0, sizeof(AudioChannelLayout));
163        if(lfe)
164                acl->mChannelLayoutTag = ac3_layout_lfe[acmod];
165        else
166                acl->mChannelLayoutTag = ac3_layout_no_lfe[acmod];
167       
168        return 1;
169}
170
171static int parse_mpeg4_extra(FFusionParserContext *parser, const uint8_t *buf, int buf_size)
172{
173        ParseContext1 *pc1 = (ParseContext1 *)parser->pc->priv_data;
174        pc1->pc.frame_start_found = 0;
175       
176        MpegEncContext *s = pc1->enc;
177        GetBitContext gb1, *gb = &gb1;
178       
179        s->avctx = parser->avctx;
180        s->current_picture_ptr = &s->current_picture;
181       
182        init_get_bits(gb, buf, 8 * buf_size);
183        ff_mpeg4_decode_picture_header(s, gb);
184        return 1;
185}
186
187/*
188 * Long story short, FFMpeg's parsers suck for our use.  This function parses an mpeg4 bitstream,
189 * and assumes that it is given at least a full frame of data.
190 * @param parser A FFusionParserContext structure containg all our info
191 * @param buf The buffer to parse
192 * @param buf_size Size of the input buffer
193 * @param out_buf_size The number of bytes present in the first frame of data
194 * @param type The frame Type: FF_*_TYPE
195 * @param pts The PTS of the frame
196 * @return 1 if a frame is found, 0 otherwise
197 */
198static int parse_mpeg4_stream(FFusionParserContext *parser, const uint8_t *buf, int buf_size, int *out_buf_size, int *type, int *skippable, int *skipped)
199{
200        ParseContext1 *pc1 = (ParseContext1 *)parser->pc->priv_data;
201        pc1->pc.frame_start_found = 0;
202       
203        int endOfFrame = ff_mpeg4_find_frame_end(&(pc1->pc), buf, buf_size);
204       
205        MpegEncContext *s = pc1->enc;
206        GetBitContext gb1, *gb = &gb1;
207       
208        s->avctx = parser->avctx;
209        s->current_picture_ptr = &s->current_picture;
210       
211        init_get_bits(gb, buf, 8 * buf_size);
212        int parse_res = ff_mpeg4_decode_picture_header(s, gb);
213        if(parse_res == FRAME_SKIPPED) {
214                *out_buf_size = buf_size;
215                *type = FF_P_TYPE;
216                *skippable = 1;
217                *skipped = 1;
218        }
219        if(parse_res != 0)
220                return 0;
221       
222        *type = s->pict_type;
223        *skippable = (*type == FF_B_TYPE);
224        *skipped = 0;
225#if 0 /*this was an attempt to figure out the PTS information and detect an out of order P frame before we hit its B frame */
226        int64_t *lastPtsPtr = (int64_t *)parser->internalContext;
227        int64_t lastPts = *lastPtsPtr;
228        int64_t currentPts = s->current_picture.pts;
229       
230        switch(s->pict_type)
231        {
232                case FF_I_TYPE:
233                        *lastPtsPtr = currentPts;
234                        *precedesAPastFrame = 0;
235                        break;
236                case FF_P_TYPE:
237                        if(currentPts > lastPts + 1)
238                                *precedesAPastFrame = 1;
239                        else
240                                *precedesAPastFrame = 0;
241                        *lastPtsPtr = currentPts;
242                        break;
243                case FF_B_TYPE:
244                        *precedesAPastFrame = 0;
245                        break;
246                default:
247                        break;
248        }
249#endif
250       
251        if(endOfFrame == END_NOT_FOUND)
252                *out_buf_size = buf_size;
253        else
254                *out_buf_size = endOfFrame;
255        return 1;
256}
257
258static int parse_mpeg12_stream(FFusionParserContext *ffparser, const uint8_t *buf, int buf_size, int *out_buf_size, int *type, int *skippable, int *skipped)
259{
260        const uint8_t *out_unused;
261        int size_unused;
262        AVCodecParser *parser = ffparser->pc->parser;
263       
264        parser->parser_parse(ffparser->pc, ffparser->avctx, &out_unused, &size_unused, buf, buf_size);
265       
266        *out_buf_size = buf_size;
267        *type = ffparser->pc->pict_type;
268        *skippable = *type == FF_B_TYPE;
269        *skipped = 0;
270       
271        return 1;
272}
273
274extern AVCodecParser mpeg4video_parser;
275
276static FFusionParser ffusionMpeg4VideoParser = {
277        &mpeg4video_parser,
278        0,
279        NULL,
280        parse_mpeg4_extra,
281        parse_mpeg4_stream,
282};
283
284extern AVCodecParser mpegvideo_parser;
285
286static FFusionParser ffusionMpeg12VideoParser = {
287        &mpegvideo_parser,
288        0,
289        NULL,
290        NULL,
291        parse_mpeg12_stream,
292};
293
294typedef struct H264ParserContext_s
295{
296        int is_avc;
297        int nal_length_size;
298        int prevPts;
299       
300        int profile_idc;
301        int level_idc;
302       
303        int poc_type;
304        int log2_max_frame_num;
305        int frame_mbs_only_flag;
306        int num_reorder_frames;
307        int pic_order_present_flag;
308
309        int log2_max_poc_lsb;
310        int poc_msb;
311        int prev_poc_lsb;
312
313        int delta_pic_order_always_zero_flag;
314        int offset_for_non_ref_pic;
315        int num_ref_frames_in_pic_order_cnt_cycle;
316        int sum_of_offset_for_ref_frames;
317       
318        int chroma_format_idc;
319       
320        int gaps_in_frame_num_value_allowed_flag;
321}H264ParserContext;
322
323static int decode_nal(const uint8_t *buf, int buf_size, uint8_t *out_buf, int *out_buf_size, int *type, int *nal_ref_idc)
324{
325        int i;
326        int outIndex = 0;
327        int numNulls = 0;
328       
329        for(i=1; i<buf_size; i++)
330        {
331                if(buf[i] == 0)
332                        numNulls++;
333                else if(numNulls == 2)
334                {
335                        numNulls = 0;
336                        if(buf[i] < 3)
337                        {
338                                /* end of nal */
339                                outIndex -= 2;
340                                break;
341                        }
342                        else if(buf[i] == 3)
343                                /* This is just a simple escape of 0x00 00 03 */
344                                continue;
345                }
346                else
347                        numNulls = 0;
348                out_buf[outIndex] = buf[i];
349                outIndex++;
350        }
351       
352        if(outIndex <= 0)
353                return 0;
354       
355        *type = buf[0] & 0x1f;
356        *nal_ref_idc = (buf[0] >> 5) & 0x03;
357        *out_buf_size = outIndex;
358        return 1;
359}
360
361static void skip_scaling_list(GetBitContext *gb, int size){
362        int i, next = 8, last = 8;
363       
364    if(get_bits1(gb)) /* matrix not written, we use the predicted one */
365                for(i=0;i<size;i++){
366                        if(next)
367                                next = (last + get_se_golomb(gb)) & 0xff;
368                        if(!i && !next){ /* matrix not written, we use the preset one */
369                                break;
370                        }
371                        last = next ? next : last;
372                }
373}
374
375static void skip_scaling_matrices(GetBitContext *gb){
376    if(get_bits1(gb)){
377        skip_scaling_list(gb, 16); // Intra, Y
378        skip_scaling_list(gb, 16); // Intra, Cr
379        skip_scaling_list(gb, 16); // Intra, Cb
380        skip_scaling_list(gb, 16); // Inter, Y
381        skip_scaling_list(gb, 16); // Inter, Cr
382        skip_scaling_list(gb, 16); // Inter, Cb
383                skip_scaling_list(gb, 64);  // Intra, Y
384                skip_scaling_list(gb, 64);  // Inter, Y
385        }
386}
387
388static void skip_hrd_parameters(GetBitContext *gb)
389{
390        int cpb_cnt_minus1 = get_ue_golomb(gb);
391        get_bits(gb, 4);        //bit_rate_scale
392        get_bits(gb, 4);        //cpb_size_scale
393        int i;
394        for(i=0; i<=cpb_cnt_minus1; i++)
395        {
396                get_ue_golomb(gb);      //bit_rate_value_minus1[i]
397                get_ue_golomb(gb);      //cpb_size_value_minus1[i]
398                get_bits1(gb);          //cbr_flag[i]
399        }
400        get_bits(gb, 5);        //initial_cpb_removal_delay_length_minus1
401        get_bits(gb, 5);        //cpb_removal_delay_length_minus1
402        get_bits(gb, 5);        //dpb_output_delay_length_minus1
403        get_bits(gb, 5);        //time_offset_length
404}
405
406static void decode_sps(H264ParserContext *context, const uint8_t *buf, int buf_size)
407{
408        GetBitContext getbit, *gb = &getbit;
409       
410        init_get_bits(gb, buf, 8 * buf_size);
411    context->profile_idc= get_bits(gb, 8);
412    get_bits1(gb);              //constraint_set0_flag
413    get_bits1(gb);              //constraint_set1_flag
414    get_bits1(gb);              //constraint_set2_flag
415    get_bits1(gb);              //constraint_set3_flag
416    get_bits(gb, 4);    //reserved
417        context->level_idc = get_bits(gb, 8);   //level_idc
418        get_ue_golomb(gb);      //seq_parameter_set_id
419        if(context->profile_idc >= 100)
420        {
421                context->chroma_format_idc = get_ue_golomb(gb);
422                //high profile
423                if(context->chroma_format_idc == 3)     //chroma_format_idc
424                        get_bits1(gb);                  //residual_color_transfrom_flag
425                get_ue_golomb(gb);                      //bit_depth_luma_minus8
426                get_ue_golomb(gb);                      //bit_depth_chroma_minus8
427                get_bits1(gb);                          //transform_bypass
428                skip_scaling_matrices(gb);
429        }
430        context->log2_max_frame_num = get_ue_golomb(gb) + 4;
431        context->poc_type = get_ue_golomb(gb);
432        if(context->poc_type == 0)
433                context->log2_max_poc_lsb = get_ue_golomb(gb) + 4;
434        else if(context->poc_type == 1)
435        {
436                int i;
437               
438                context->delta_pic_order_always_zero_flag = get_bits1(gb);
439                context->offset_for_non_ref_pic = get_se_golomb(gb);
440                get_se_golomb(gb);      //offset_for_top_to_bottom_field
441                context->num_ref_frames_in_pic_order_cnt_cycle = get_ue_golomb(gb);
442                context->sum_of_offset_for_ref_frames = 0;
443                for(i=0; i<context->num_ref_frames_in_pic_order_cnt_cycle; i++)
444                        context->sum_of_offset_for_ref_frames += get_se_golomb(gb); //offset_for_ref_frame[i]
445        }
446        get_ue_golomb(gb);      //num_ref_frames
447        context->gaps_in_frame_num_value_allowed_flag = get_bits1(gb);          //gaps_in_frame_num_value_allowed_flag
448        get_ue_golomb(gb);      //pic_width_in_mbs_minus1
449        get_ue_golomb(gb);      //pic_height_in_map_units_minus1
450        int mbs_only = get_bits1(gb);
451        context->frame_mbs_only_flag = mbs_only;
452#if 1           //This is a test to get num_reorder_frames
453        if(!mbs_only)
454                get_bits1(gb);  //mb_adaptive_frame_field_flag
455        get_bits1(gb);          //direct_8x8_inference_flag
456        if(get_bits1(gb))       //frame_cropping_flag
457        {
458                get_ue_golomb(gb);      //frame_crop_left_offset
459                get_ue_golomb(gb);      //frame_crop_right_offset
460                get_ue_golomb(gb);      //frame_crop_top_offset
461                get_ue_golomb(gb);      //frame_crop_bottom_offset
462        }
463        if(get_bits1(gb))       //vui_parameters_present_flag
464        {
465                if(get_bits1(gb))       //aspect_ratio_info_present_flag
466                {
467                        if(get_bits(gb, 8) == 255)      //aspect_ratio_idc
468                        {
469                                get_bits(gb, 16);       //sar_width
470                                get_bits(gb, 16);       //sar_height
471                        }
472                }
473                if(get_bits1(gb))       //overscan_info_present_flag
474                        get_bits1(gb);  //overscan_appropriate_flag
475                if(get_bits1(gb))       //video_signal_type_present_flag
476                {
477                        get_bits(gb, 3);        //video_format
478                        get_bits1(gb);          //video_full_range_flag
479                        if(get_bits1(gb))       //colour_description_present_flag
480                        {
481                                get_bits(gb, 8);        //colour_primaries
482                                get_bits(gb, 8);        //transfer_characteristics
483                                get_bits(gb, 8);        //matrix_coefficients
484                        }
485                }
486                if(get_bits1(gb))       //chroma_loc_info_present_flag
487                {
488                        get_ue_golomb(gb);      //chroma_sample_loc_type_top_field
489                        get_ue_golomb(gb);      //chroma_sample_loc_type_bottom_field
490                }
491                if(get_bits1(gb))       //timing_info_present_flag
492                {
493                        get_bits(gb, 32);       //num_units_in_tick
494                        get_bits(gb, 32);       //time_scale
495                        get_bits1(gb);  //fixed_frame_rate_flag
496                }
497                int nal_hrd_parameters_present_flag = get_bits1(gb);
498                if(nal_hrd_parameters_present_flag)
499                {
500                        skip_hrd_parameters(gb);
501                }
502                int vcl_hrd_parameters_present_flag = get_bits1(gb);
503                if(vcl_hrd_parameters_present_flag)
504                {
505                        skip_hrd_parameters(gb);
506                }
507                if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
508                        get_bits1(gb);  //low_delay_hrd_flag
509                get_bits1(gb);  //pic_struct_present_flag
510                if(get_bits1(gb))       //bitstream_restriction_flag
511                {
512                        get_bits1(gb);  //motion_vectors_over_pic_boundaries_flag
513                        get_ue_golomb(gb);      //max_bytes_per_pic_denom
514                        get_ue_golomb(gb);      //max_bits_per_mb_denom
515                        get_ue_golomb(gb);      //log2_max_mv_length_horizontal
516                        get_ue_golomb(gb);      //log2_max_mv_length_vertical
517                        context->num_reorder_frames = get_ue_golomb(gb);
518                        get_ue_golomb(gb);      //max_dec_frame_buffering                       
519                }
520        }
521#endif
522}
523
524static void decode_pps(H264ParserContext *context, const uint8_t *buf, int buf_size)
525{
526        GetBitContext getbit, *gb = &getbit;
527       
528        init_get_bits(gb, buf, 8 * buf_size);
529        get_ue_golomb(gb); //pic_parameter_set_id
530        get_ue_golomb(gb); //seq_parameter_set_id
531        get_bits1(gb); //entropy_coding_mode_flag
532        context->pic_order_present_flag = get_bits1(gb);
533}
534
535static int inline decode_slice_header(H264ParserContext *context, const uint8_t *buf, int buf_size, int nal_ref_idc, int nal_type, int just_type, int *type, int *pts)
536{
537        GetBitContext getbit, *gb = &getbit;
538        int slice_type;
539        int field_pic_flag = 0;
540        int bottom_field_flag = 0;
541        int frame_number;
542//      static const uint8_t slice_type_map[5] = {FF_P_TYPE, FF_B_TYPE, FF_I_TYPE, FF_SP_TYPE, FF_SI_TYPE};
543        static const uint8_t slice_type_map[5] = {FF_P_TYPE, FF_P_TYPE, FF_I_TYPE, FF_SP_TYPE, FF_SI_TYPE};
544       
545        init_get_bits(gb, buf, 8 * buf_size);
546       
547        get_ue_golomb(gb);      //first_mb_in_slice
548        slice_type = get_ue_golomb(gb);
549        if(slice_type > 9)
550                return 0;
551       
552        if(slice_type > 4)
553                slice_type -= 5;
554       
555        *type = slice_type_map[slice_type];
556        if(just_type)
557                return 1;
558       
559        get_ue_golomb(gb); //pic_parameter_set_id
560        frame_number = get_bits(gb, context->log2_max_frame_num);
561        if(!context->frame_mbs_only_flag)
562        {
563                field_pic_flag = get_bits1(gb);
564                if(field_pic_flag)
565                {
566                        bottom_field_flag = get_bits1(gb);
567                }
568        }
569        if(nal_type == 5)
570                get_ue_golomb(gb);  //idr_pic_id
571        if(context->poc_type == 0)
572        {
573                int pts_lsb = get_bits(gb, context->log2_max_poc_lsb);
574                int delta_pic_order_cnt_bottom = 0;
575                int maxPicOrderCntLsb = 1 << context->log2_max_poc_lsb;
576                int pic_order_msb;
577               
578                if(context->pic_order_present_flag && !field_pic_flag)
579                        delta_pic_order_cnt_bottom = get_se_golomb(gb);
580                if((pts_lsb < context->prev_poc_lsb) && (context->prev_poc_lsb - pts_lsb) >= maxPicOrderCntLsb)
581                        pic_order_msb = context->poc_msb + maxPicOrderCntLsb;
582                else if((pts_lsb > context->prev_poc_lsb) && (pts_lsb - context->prev_poc_lsb) > maxPicOrderCntLsb)
583                        pic_order_msb = context->poc_msb - maxPicOrderCntLsb;
584                else
585                        pic_order_msb = context->poc_msb;
586               
587                context->poc_msb = pic_order_msb;
588               
589                *pts = pic_order_msb + pts_lsb;
590                if(delta_pic_order_cnt_bottom < 0)
591                        *pts += delta_pic_order_cnt_bottom;
592                       
593        }
594        else if(context->poc_type == 1 && !context->delta_pic_order_always_zero_flag)
595        {
596                int delta_pic_order_cnt[2] = {0, 0};
597                delta_pic_order_cnt[0] = get_se_golomb(gb);
598                if(context->pic_order_present_flag && !field_pic_flag)
599                        delta_pic_order_cnt[1] = get_se_golomb(gb);
600               
601                int frame_num_offset = 0;  //I think this is wrong, but the pts code isn't used anywhere, so no harm yet and this removes a warning.
602               
603                int abs_frame_num = 0;
604                int num_ref_frames_in_pic_order_cnt_cycle = context->num_ref_frames_in_pic_order_cnt_cycle;
605                if(num_ref_frames_in_pic_order_cnt_cycle != 0)
606                        abs_frame_num = frame_num_offset + frame_number;
607               
608                if(nal_ref_idc == 0 && abs_frame_num > 0)
609                        abs_frame_num--;
610               
611                int expected_delta_per_poc_cycle = context->sum_of_offset_for_ref_frames;
612                int expectedpoc = 0;
613                if(abs_frame_num > 0)
614                {
615                        int poc_cycle_cnt = (abs_frame_num - 1) / num_ref_frames_in_pic_order_cnt_cycle;
616                       
617                        expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle + context->sum_of_offset_for_ref_frames;
618                }
619               
620                if(nal_ref_idc == 0)
621                        expectedpoc = expectedpoc + context->offset_for_non_ref_pic;
622                *pts = expectedpoc + delta_pic_order_cnt[0];
623        }
624       
625        return 1;
626}
627
628#define NAL_PEEK_SIZE 32
629
630static int inline decode_nals(H264ParserContext *context, const uint8_t *buf, int buf_size, int *type, int *skippable)
631{
632        int nalsize = 0;
633        int buf_index = 0;
634        int ret = 0;
635        int pts_decoded = 0;
636        int lowestType = 20;
637       
638        *skippable = 1;
639       
640#if 0 /*this was an attempt to figure out the PTS information and detect an out of order P frame before we hit its B frame */
641        if(context->poc_type == 2)
642        {
643                //decode and display order are the same
644                pts_decoded = 1;
645                *precedesAPastFrame = 0;
646        }
647#endif
648       
649        for(;;)
650        {
651                if(context->is_avc)
652                {
653                        if(buf_index >= buf_size)
654                                break;
655                        nalsize = 0;
656                        switch (context->nal_length_size) {
657                                case 1:
658                                        nalsize = buf[buf_index];
659                                        buf_index++;
660                                        break;
661                                case 2:
662                                        nalsize = (buf[buf_index] << 8) | buf[buf_index+1];
663                                        buf_index += 2;
664                                        break;
665                                case 3:
666                                        nalsize = (buf[buf_index] << 16) | (buf[buf_index+1] << 8) | buf[buf_index + 2];
667                                        buf_index += 3;
668                                        break;
669                                case 4:
670                                        nalsize = (buf[buf_index] << 24) | (buf[buf_index+1] << 16) | (buf[buf_index + 2] << 8) | buf[buf_index + 3];
671                                        buf_index += 4;
672                                        break;
673                                default:
674                                        break;
675                        }
676                        if(nalsize <= 1 || nalsize > buf_size)
677                        {
678                                if(nalsize == 1)
679                                {
680                                        buf_index++;
681                                        continue;
682                                }
683                                else
684                                        break;
685                        }
686                }
687                else
688                {
689                        int num_nuls = 0;
690                        int start_offset = 0;
691                        //do start code prefix search
692                        for(; buf_index < buf_size; buf_index++)
693                        {
694                                if(buf[buf_index] == 0)
695                                        num_nuls++;
696                                else
697                                {
698                                        if(num_nuls >= 2 && buf[buf_index] == 1)
699                                                break;
700                                        num_nuls = 0;
701                                }
702                        }
703                        start_offset = buf_index + 1;
704                        //do start code prefix search
705                        for(buf_index++; buf_index < buf_size; buf_index++)
706                        {
707                                if(buf[buf_index] == 0)
708                                {
709                                        if(num_nuls == 2)
710                                                break;
711                                        num_nuls++;
712                                }
713                                else
714                                {
715                                        if(num_nuls == 2 && buf[buf_index] == 1)
716                                                break;
717                                        num_nuls = 0;
718                                }
719                        }
720                        if(start_offset >= buf_size)
721                                //no more
722                                break;
723                        nalsize = buf_index - start_offset;
724                        if(buf_index < buf_size)
725                                //Take off the next NAL's startcode
726                                nalsize -= 2;
727                        //skip the start code
728                        buf_index = start_offset;
729                }
730
731                uint8_t partOfNal[NAL_PEEK_SIZE];
732                int decodedNalSize, nalType;
733                int nal_ref_idc;
734                int slice_type = 0;
735               
736                if(decode_nal(buf + buf_index, FFMIN(nalsize, NAL_PEEK_SIZE), partOfNal, &decodedNalSize, &nalType, &nal_ref_idc))
737                {
738                        int pts = 0;
739                        if(nalType == 1 || nalType == 2)
740                        {
741                                if(decode_slice_header(context, partOfNal, decodedNalSize, nal_ref_idc, nalType, pts_decoded, &slice_type, &pts))
742                                {
743                                        ret = 1;
744                                        if(slice_type < lowestType)
745                                                lowestType = slice_type;
746                                        if(nal_ref_idc)
747                                                *skippable = 0;
748                                        if(pts_decoded == 0)
749                                        {
750                                                pts_decoded = 1;
751                                                if(pts > context->prevPts)
752                                                {
753                                                        if(pts < context->prevPts)
754                                                                lowestType = FF_B_TYPE;
755                                                        context->prevPts = pts;
756                                                }
757                                        }
758                                }
759                               
760                                // Parser users assume I-frames are IDR-frames
761                                // but in H.264 they don't have to be.
762                                // Mark these as P-frames if they effectively are.
763                                if (lowestType == FF_I_TYPE) lowestType = FF_P_TYPE;
764                        }
765                        else if(nalType == 5)
766                        {
767                                ret = 1;
768#if 0 /*this was an attempt to figure out the PTS information and detect an out of order P frame before we hit its B frame */
769                                context->prev_poc_lsb = 0;
770                                context->poc_msb = 0;
771                                context->prevPts = 0;
772                                *precedesAPastFrame = 0;
773#endif
774                                *skippable = 0;
775                                lowestType = FF_I_TYPE;
776                        }
777                }
778                buf_index += nalsize;
779        }
780        if(lowestType != 20)
781                *type = lowestType;
782       
783        return ret;
784}
785
786/*
787 * This function parses an h.264 bitstream, and assumes that it is given at least a full frame of data.
788 * @param parser A FFusionParserContext structure containg all our info
789 * @param buf The buffer to parse
790 * @param buf_size Size of the input buffer
791 * @param out_buf_size The number of bytes present in the first frame of data
792 * @param type The frame Type: FF_*_TYPE
793 * @param pts The PTS of the frame
794 * @return 1 if a frame is found, 0 otherwise
795 */
796static int parse_h264_stream(FFusionParserContext *parser, const uint8_t *buf, int buf_size, int *out_buf_size, int *type, int *skippable, int *skipped)
797{
798        int endOfFrame;
799        int size = 0;
800        const uint8_t *parseBuf = buf;
801        int parseSize;
802
803        /*
804         * Somehow figure out of frame type
805         * For our use, a frame with any B slices is a B frame, and then a frame with any P slices is a P frame.
806         * An I frame has only I slices.
807         * I expect this involves a NAL decoder, and then look at the slice types.
808         * Nal is a f(1) always set to 0, u(2) of nal_ref_idc, and then u(5) of nal_unit_type.
809         * Nal types 1, 2 start a non-I frame, and type 5 starts an I frame.  Each start with a slice header.
810         * Slice header has a ue(v) for first_mb_in_slice and then a ue(v) for the slice_type
811         * Slice types 0, 5 are P, 1, 6 are B, 2, 7 are I
812         */
813       
814        do
815        {
816                parseBuf = parseBuf + size;
817                parseSize = buf_size - size;
818                endOfFrame = (parser->parserStructure->avparse->split)(parser->avctx, parseBuf, parseSize);
819                if(endOfFrame == 0)
820                        size = buf_size;
821                else
822                {
823                        size += endOfFrame;
824                        parseSize = endOfFrame;
825                }
826        }while(decode_nals(parser->internalContext, parseBuf, parseSize, type, skippable) == 0 && size < buf_size);
827               
828        *skipped = 0;
829        *out_buf_size = size;
830        return 1;
831}
832
833static int init_h264_parser(FFusionParserContext *parser)
834{
835        H264ParserContext *context = parser->internalContext;
836       
837        context->nal_length_size = 2;
838        context->is_avc = 0;
839        return 1;
840}
841
842static int parse_extra_data_h264(FFusionParserContext *parser, const uint8_t *buf, int buf_size)
843{
844        H264ParserContext *context = parser->internalContext;
845        const uint8_t *cur = buf;
846        int count, i, type, ref;
847       
848        context->is_avc = 1;
849        count = *(cur+5) & 0x1f;
850        cur += 6;
851        for (i=0; i<count; i++)
852        {
853                int size = AV_RB16(cur);
854                int out_size = 0;
855                uint8_t *decoded = av_mallocz(size+FF_INPUT_BUFFER_PADDING_SIZE);
856                if(decode_nal(cur + 2, size, decoded, &out_size, &type, &ref))
857                        decode_sps(context, decoded, out_size);
858                cur += size + 2;
859                free(decoded);
860        }
861        count = *(cur++);
862        for (i=0; i<count; i++)
863        {
864                int size = AV_RB16(cur);
865                int out_size = 0;
866                uint8_t *decoded = av_mallocz(size+FF_INPUT_BUFFER_PADDING_SIZE);
867                if(decode_nal(cur + 2, size, decoded, &out_size, &type, &ref))
868                        decode_pps(context, decoded, out_size);
869                cur += size + 2;
870                free(decoded);
871        }
872       
873        context->nal_length_size = ((*(buf+4)) & 0x03) + 1;
874       
875        return 1;
876}
877
878extern AVCodecParser h264_parser;
879
880static FFusionParser ffusionH264Parser = {
881        &h264_parser,
882        sizeof(H264ParserContext),
883        init_h264_parser,
884        parse_extra_data_h264,
885        parse_h264_stream,
886};
887
888static FFusionParser *ffusionFirstParser = NULL;
889
890void registerFFusionParsers(FFusionParser *parser)
891{
892    parser->next = ffusionFirstParser;
893    ffusionFirstParser = parser;
894}
895
896void initFFusionParsers()
897{
898        static Boolean inited = FALSE;
899        int unlock = PerianInitEnter(&inited);
900       
901        if(!inited)
902        {
903                inited = TRUE;
904                registerFFusionParsers(&ffusionMpeg4VideoParser);
905                registerFFusionParsers(&ffusionH264Parser);
906                registerFFusionParsers(&ffusionMpeg12VideoParser);
907        }
908       
909        PerianInitExit(unlock);
910}
911
912void ffusionParserFree(FFusionParserContext *parser)
913{
914        AVCodecParser *avparse = parser->parserStructure->avparse;
915       
916        if(parser->pc)
917        {
918                if (avparse->parser_close)
919                        avparse->parser_close(parser->pc);
920                av_free(parser->pc->priv_data);
921                av_free(parser->pc);
922        }
923        av_free(parser->avctx);
924        av_free(parser->internalContext);
925        free(parser);
926}
927
928FFusionParserContext *ffusionParserInit(int codec_id)
929{
930    AVCodecParserContext *s;
931    AVCodecParser *parser;
932        FFusionParser *ffParser;
933    int ret, i;
934       
935    if(codec_id == CODEC_ID_NONE)
936        return NULL;
937       
938        if (!ffusionFirstParser) initFFusionParsers();
939       
940    for(ffParser = ffusionFirstParser; ffParser != NULL; ffParser = ffParser->next) {
941                parser = ffParser->avparse;
942               
943                for (i = 0; i < 5; i++)
944                        if (parser->codec_ids[i] == codec_id)
945                                goto found;
946    }
947    return NULL;
948found:
949        s = av_mallocz(sizeof(AVCodecParserContext));
950    if (!s)
951        return NULL;
952    s->parser = parser;
953    s->priv_data = av_mallocz(parser->priv_data_size);
954    if (!s->priv_data) {
955        av_free(s);
956        return NULL;
957    }
958    if (parser->parser_init) {
959        ret = parser->parser_init(s);
960        if (ret != 0) {
961            av_free(s->priv_data);
962            av_free(s);
963            return NULL;
964        }
965    }
966    s->fetch_timestamp=1;
967        s->flags |= PARSER_FLAG_COMPLETE_FRAMES;
968       
969        FFusionParserContext *parserContext = malloc(sizeof(FFusionParserContext));
970        parserContext->avctx = avcodec_alloc_context();
971        parserContext->pc = s;
972        parserContext->parserStructure = ffParser;
973        if(ffParser->internalContextSize)
974                parserContext->internalContext = av_mallocz(ffParser->internalContextSize);
975        else
976                parserContext->internalContext = NULL;
977        if(ffParser->init)
978                (ffParser->init)(parserContext);
979    return parserContext;
980}
981
982/*
983 * @param parser FFusionParserContext pointer
984 * @param buf The buffer to parse
985 * @param buf_size Size of the input buffer
986 * @return 1 if successful, 0 otherwise
987 */
988 int ffusionParseExtraData(FFusionParserContext *parser, const uint8_t *buf, int buf_size)
989{
990         if(parser->parserStructure->extra_data)
991                 return (parser->parserStructure->extra_data)(parser, buf, buf_size);
992         return 1;       
993}
994
995/*
996 * @param parser FFusionParserContext pointer
997 * @param buf The buffer to parse
998 * @param buf_size Size of the input buffer
999 * @param out_buf_size The number of bytes present in the first frame of data
1000 * @param type The frame Type: FF_*_TYPE
1001 * @param skippable If nothing depends on the frame
1002 * @param skipped If the frame is an N-vop or equivalent
1003 * @return 1 if a frame is found, 0 otherwise
1004 */
1005int ffusionParse(FFusionParserContext *parser, const uint8_t *buf, int buf_size, int *out_buf_size, int *type, int *skippable, int *skipped)
1006{
1007        if(parser->parserStructure->parser_parse)
1008                return (parser->parserStructure->parser_parse)(parser, buf, buf_size, out_buf_size, type, skippable, skipped);
1009        return 0;
1010}
1011
1012void ffusionLogDebugInfo(FFusionParserContext *parser, FILE *log)
1013{
1014        if (parser) {
1015                if (parser->parserStructure == &ffusionH264Parser) {
1016                        H264ParserContext *h264parser = parser->internalContext;
1017                       
1018                        Codecprintf(log, "H.264 format: profile %d level %d\n\tis_avc %d\n\tframe_mbs_only %d\n\tchroma_format_idc %d\n\tframe_num_gaps %d\n\tnum_reorder_frames %d\n",
1019                                                h264parser->profile_idc, h264parser->level_idc, h264parser->is_avc, h264parser->frame_mbs_only_flag, h264parser->chroma_format_idc, h264parser->gaps_in_frame_num_value_allowed_flag,
1020                                                h264parser->num_reorder_frames);
1021                }
1022        }
1023}
1024
1025FFusionDecodeAbilities ffusionIsParsedVideoDecodable(FFusionParserContext *parser)
1026{
1027        if (!parser) return FFUSION_PREFER_DECODE;
1028       
1029        if (parser->parserStructure == &ffusionH264Parser) {
1030                H264ParserContext *h264parser = parser->internalContext;
1031                FFusionDecodeAbilities ret = FFUSION_PREFER_DECODE;
1032               
1033                //QT is bad at high profile
1034                //and x264 B-pyramid (sps.vui.num_reorder_frames > 1)
1035                if(h264parser->profile_idc < 100 && h264parser->num_reorder_frames < 2 && 
1036                   !CFPreferencesGetAppBooleanValue(CFSTR("DecodeAllProfiles"), PERIAN_PREF_DOMAIN, NULL))
1037                        ret = FFUSION_PREFER_NOT_DECODE;
1038               
1039                //PAFF/MBAFF
1040                //ffmpeg is ok at this now but we can't test it (not enough AVCHD samples)
1041                //and the quicktime api for it may or may not actually exist
1042                if(!h264parser->frame_mbs_only_flag)
1043                        ret = FFUSION_CANNOT_DECODE;
1044               
1045                //4:2:2 chroma
1046                if(h264parser->chroma_format_idc > 1)
1047                        ret = FFUSION_CANNOT_DECODE;
1048               
1049                return ret;
1050        }
1051       
1052        return FFUSION_PREFER_DECODE;
1053}
1054#ifdef DEBUG_BUILD
1055//FFMPEG doesn't configure properly (their fault), so define their idoticly undefined symbols.
1056int ff_epzs_motion_search(MpegEncContext * s, int *mx_ptr, int *my_ptr, int P[10][2], int src_index, int ref_index, int16_t (*last_mv)[2], int ref_mv_scale, int size, int h){return 0;}
1057int ff_get_mb_score(MpegEncContext * s, int mx, int my, int src_index,int ref_index, int size, int h, int add_rate){return 0;}
1058int ff_init_me(MpegEncContext *s){return 0;}
1059int ff_rate_control_init(struct MpegEncContext *s){return 0;}
1060float ff_rate_estimate_qscale(struct MpegEncContext *s, int dry_run){return 0;}
1061void ff_write_pass1_stats(struct MpegEncContext *s){}
1062void h263_encode_init(MpegEncContext *s){}
1063#endif
Note: See TracBrowser for help on using the repository browser.