source: trunk/bitstream_info.c @ 1463

Revision 1463, 29.8 KB checked in by astrange, 3 years ago (diff)

Correct wrong mFramesPerPacket value for AC3

Fixes #619

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