Ticket #668: atsc_cc-r7892.patch

File atsc_cc-r7892.patch, 12.3 KB (added by gtgj@…, 14 years ago)

ATSC/DVD CC support (dependent on ccdecoder patch)

  • libs/libmythtv/avformatdecoder.cpp

     
    158158      frame_decoded(0), directrendering(false), drawband(false), bitrate(0),
    159159      gopset(false), seen_gop(false), seq_count(0), firstgoppos(0),
    160160      prevgoppos(0), gotvideo(false), lastvpts(0), lastapts(0),
     161      lastccptsu(0),
    161162      using_null_videoout(use_null_videoout), video_codec_id(kCodec_NONE),
    162163      maxkeyframedist(-1),
     164      ccd(new CCDecoder(this)),
    163165      // Audio
    164166      audioSamples(new short int[AVCODEC_MAX_AUDIO_FRAME_SIZE]),
    165167      audio_sample_size(-1), audio_sampling_rate(-1), audio_channels(-1),
     
    173175
    174176    bool debug = (bool)(print_verbose_messages & VB_LIBAV);
    175177    av_log_set_level((debug) ? AV_LOG_DEBUG : AV_LOG_ERROR);
     178
     179    save_cctc[0] = save_cctc[1] = 0;
    176180}
    177181
    178182AvFormatDecoder::~AvFormatDecoder()
    179183{
    180184    CloseContext();
     185    delete ccd;
    181186    delete d;
    182187    if (audioSamples)
    183188        delete [] audioSamples;
     
    308313
    309314    lastapts = 0;
    310315    lastvpts = 0;
     316    lastccptsu = 0;
     317    save_cctc[0] = save_cctc[1] = 0;
    311318
    312319    av_read_frame_flush(ic);
    313320   
     
    893900                {
    894901                    d->InitMPEG2();
    895902                }
     903
     904                enc->decode_cc_dvd = decode_cc_dvd;
     905                enc->decode_cc_atsc = decode_cc_atsc;
    896906                break;
    897907            }
    898908            case CODEC_TYPE_AUDIO:
     
    12311241        cerr<<"render_slice_xvmc called with bad avctx or src"<<endl;
    12321242}
    12331243
     1244void decode_cc_dvd(struct AVCodecContext *s, const uint8_t *buf, int buf_size)
     1245{
     1246    // taken from xine-lib libspucc by Christian Vogler
     1247
     1248    AvFormatDecoder *nd = (AvFormatDecoder *)(s->opaque);
     1249    unsigned long long utc = nd->lastccptsu;
     1250
     1251    const uint8_t *current = buf;
     1252    int curbytes = 0;
     1253    uint8_t data1, data2;
     1254    uint8_t cc_code;
     1255    int odd_offset = 1;
     1256
     1257    while (curbytes < buf_size)
     1258    {
     1259        int skip = 2;
     1260
     1261        cc_code = *current++;
     1262        curbytes++;
     1263   
     1264        if (buf_size - curbytes < 2)
     1265            break;
     1266   
     1267        data1 = *current;
     1268        data2 = *(current + 1);
     1269   
     1270        switch (cc_code)
     1271        {
     1272            case 0xfe:
     1273                /* expect 2 byte encoding (perhaps CC3, CC4?) */
     1274                /* ignore for time being */
     1275                skip = 2;
     1276                break;
     1277
     1278            case 0xff:
     1279            {
     1280                /* expect EIA-608 CC1/CC2 encoding */
     1281                int tc = utc / 1000;
     1282                int data = (data2 << 8) | data1;
     1283                nd->ccd->FormatCCField(tc, 0, data);
     1284                utc += 33367;
     1285                skip = 5;
     1286                break;
     1287            }
     1288
     1289            case 0x00:
     1290                /* This seems to be just padding */
     1291                skip = 2;
     1292                break;
     1293
     1294            case 0x01:
     1295                odd_offset = data2 & 0x80;
     1296                if (odd_offset)
     1297                    skip = 2;
     1298                else
     1299                    skip = 5;
     1300                break;
     1301
     1302            default:
     1303                // rest is not needed?
     1304                goto done;
     1305                //skip = 2;
     1306                //break;
     1307        }
     1308        current += skip;
     1309        curbytes += skip;
     1310
     1311    }
     1312done:
     1313    nd->lastccptsu = utc;
     1314}
     1315
     1316void decode_cc_atsc(struct AVCodecContext *s, const uint8_t *buf, int buf_size)
     1317{
     1318    AvFormatDecoder *nd = (AvFormatDecoder *)(s->opaque);
     1319    unsigned long long utc = nd->lastccptsu;
     1320
     1321    const uint8_t *current = buf;
     1322    int curbytes = 0;
     1323    int curcount = 0;
     1324    uint8_t data1, data2;
     1325    uint8_t cc_count;
     1326    uint8_t cc_code;
     1327    int  cc_state;
     1328
     1329    if (buf_size < 2)
     1330        return;
     1331
     1332    // check process_cc_data_flag
     1333    if (!(*current & 0x40))
     1334        return;
     1335    cc_count = *current & 0x1f;
     1336    current++;  curbytes++;
     1337
     1338    // skip em_data
     1339    current++;  curbytes++;
     1340
     1341    cc_state = 0;
     1342    while (curbytes < buf_size && curcount < cc_count)
     1343    {
     1344        cc_code = *current++;
     1345        curbytes++;
     1346   
     1347        if (buf_size - curbytes < 2)
     1348            break;
     1349   
     1350        data1 = *current++;
     1351        data2 = *current++;
     1352        curbytes += 2;
     1353        curcount++;
     1354
     1355        // check cc_valid
     1356        if (!(cc_code & 0x04))
     1357            continue;
     1358
     1359        cc_code &= 0x03;
     1360        switch (cc_code)
     1361        {
     1362            case 0x00:
     1363            case 0x01:
     1364                // EIA-608 field-1/2
     1365                int data = (data2 << 8) | data1;
     1366                unsigned int tc;
     1367
     1368                if ((cc_state & cc_code) == cc_code)
     1369                {
     1370                    // another field of same type -- assume
     1371                    // it's for the next frame
     1372                    utc += 33367;
     1373                    cc_state = 0;
     1374                }
     1375                cc_state |= cc_code;
     1376                tc = utc / 1000;
     1377
     1378                // For some reason, one frame can be out of order.
     1379                // We need to save the CC codes for at least one
     1380                // frame so we can send the correct sequence to the
     1381                // decoder.
     1382
     1383                if (nd->save_cctc[cc_code])
     1384                {
     1385                    if (nd->save_cctc[cc_code] < tc)
     1386                    {
     1387                        // send saved code to decoder
     1388                        nd->ccd->FormatCCField(nd->save_cctc[cc_code],
     1389                                               cc_code,
     1390                                               nd->save_ccdata[cc_code]);
     1391                        nd->save_cctc[cc_code] = 0;
     1392                    }
     1393                    else if ((nd->save_cctc[cc_code] - tc) > 1000)
     1394                    {
     1395                        // saved code is too far in the future; probably bad
     1396                        // - discard it
     1397                        nd->save_cctc[cc_code] = 0;
     1398                    }
     1399                    else
     1400                    {
     1401                        // send new code to decoder
     1402                        nd->ccd->FormatCCField(tc, cc_code, data);
     1403                    }
     1404                }
     1405                if (!nd->save_cctc[cc_code])
     1406                {
     1407                    // no saved code
     1408                    // - save new code since it may be out of order
     1409                    nd->save_cctc[cc_code] = tc;
     1410                    nd->save_ccdata[cc_code] = data;
     1411                }
     1412                break;
     1413            case 0x02:
     1414                // TODO:  EIA-708 DTVCC packet data
     1415                break;
     1416            case 0x03:
     1417                // TODO:  EIA-708 DTVCC packet start
     1418                break;
     1419        }
     1420
     1421    }
     1422    nd->lastccptsu = utc;
     1423}
     1424
    12341425void AvFormatDecoder::HandleGopStart(AVPacket *pkt)
    12351426{
    12361427    if (prevgoppos != 0 && keyframedist != 1)
     
    14061597
    14071598                        gopset = false;
    14081599                        prevgoppos = 0;
    1409                         lastapts = lastvpts = 0;
     1600                        lastapts = lastvpts = lastccptsu = 0;
    14101601                    }
    14111602
    14121603                    seq_count++;
     
    20232214                }
    20242215                case CODEC_TYPE_VIDEO:
    20252216                {
     2217                    if (firstloop && pts != (int64_t)AV_NOPTS_VALUE)
     2218                        lastccptsu = (long long)(av_q2d(curstream->time_base) *
     2219                                                 pkt->pts * 1000000);
     2220
    20262221                    if (onlyvideo < 0)
    20272222                    {
    20282223                        framesPlayed++;
     
    22212416    return len;  // consume whole frame even if len > enc_len ?
    22222417}
    22232418
     2419void AvFormatDecoder::AddTextData(unsigned char *buf, int len,
     2420                                  long long timecode, char type)
     2421{
     2422    m_parent->AddTextData((char *)buf, len, timecode, type);
     2423}
     2424
  • libs/libmythtv/avformatdecoder.h

     
    77#include "programinfo.h"
    88#include "format.h"
    99#include "decoderbase.h"
     10#include "ccdecoder.h"
    1011
    1112extern "C" {
    1213#include "frame.h"
     
    2425/// The AvFormatDecoder is used to decode non-NuppleVideo files.
    2526/// It's used a a decoder of last resort after trying the NuppelDecoder
    2627/// and IvtvDecoder (if "USING_IVTV" is defined).
    27 class AvFormatDecoder : public DecoderBase
     28class AvFormatDecoder : public DecoderBase, public CCReader
    2829{
    2930    friend void HandleStreamChange(void*);
    3031  public:
     
    7778    virtual bool setCurrentAudioTrack(int trackNo);   
    7879    virtual QStringList listAudioTracks() const;
    7980
     81    void AddTextData(unsigned char *buf, int len, long long timecode, char type);
     82
    8083    virtual void incCurrentSubtitleTrack();
    8184    virtual void decCurrentSubtitleTrack();
    8285    virtual bool setCurrentSubtitleTrack(int trackNo);   
     
    106109    friend void render_slice_xvmc(struct AVCodecContext *c, const AVFrame *src,
    107110                                  int offset[4], int y, int type, int height);
    108111
     112    friend void decode_cc_dvd(struct AVCodecContext *c, const uint8_t *buf, int buf_size);
     113    friend void decode_cc_atsc(struct AVCodecContext *c, const uint8_t *buf, int buf_size);
     114
    109115    friend int open_avf(URLContext *h, const char *filename, int flags);
    110116    friend int read_avf(URLContext *h, uint8_t *buf, int buf_size);
    111117    friend int write_avf(URLContext *h, uint8_t *buf, int buf_size);
     
    168174
    169175    long long lastvpts;
    170176    long long lastapts;
     177    long long lastccptsu;
     178    unsigned int save_cctc[2];
     179    int save_ccdata[2];
    171180
    172181    bool using_null_videoout;
    173182    MythCodecID video_codec_id;
    174183
    175184    int maxkeyframedist;
    176185
     186    CCDecoder *ccd;
     187
    177188    // Audio
    178189    short int        *audioSamples;
    179190    int               audio_sample_size;
  • libs/libavcodec/mpeg12.c

     
    29872987                return;
    29882988            avctx->dtg_active_format = p[0] & 0x0f;
    29892989        }
     2990    } else if (len >= 3 &&
     2991               p[0] == 'C' && p[1] == 'C') {
     2992        p += 2;
     2993        len -= 2;
     2994        avctx->decode_cc_dvd(avctx, p, len);
     2995    } else if (len >= 6 &&
     2996               p[0] == 0x47 && p[1] == 0x41 && p[2] == 0x39 && p[3] == 0x34 &&
     2997               p[4] == 0x03) {
     2998        p += 5;
     2999        len -= 5;
     3000        avctx->decode_cc_atsc(avctx, p, len);
    29903001    }
     3002
    29913003}
    29923004
    29933005static void mpeg_decode_gop(AVCodecContext *avctx,
  • libs/libavcodec/utils.c

     
    423423    return 0;
    424424}
    425425
     426void avcodec_default_decode_cc_dvd(AVCodecContext *c, const uint8_t *buf, int buf_size){
     427}
     428
     429void avcodec_default_decode_cc_atsc(AVCodecContext *c, const uint8_t *buf, int buf_size){
     430}
     431
    426432enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt){
    427433    return fmt[0];
    428434}
     
    758764    s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
    759765    s->palctrl = NULL;
    760766    s->reget_buffer= avcodec_default_reget_buffer;
     767
     768    s->decode_cc_dvd= avcodec_default_decode_cc_dvd;
     769    s->decode_cc_atsc= avcodec_default_decode_cc_atsc;
    761770}
    762771
    763772/**
  • libs/libavcodec/avcodec.h

     
    18581858     */
    18591859    int xvmc_vld_hwslice;
    18601860
     1861    /**
     1862     * Closed Caption decoder
     1863     * - encoding: forbidden
     1864     * - decoding: set by decoder
     1865     */
     1866    void (*decode_cc_dvd)(struct AVCodecContext *c, const uint8_t *buf, int buf_size);
     1867    void (*decode_cc_atsc)(struct AVCodecContext *c, const uint8_t *buf, int buf_size);
     1868
    18611869} AVCodecContext;
    18621870
    18631871/**
     
    22612269int avcodec_thread_execute(AVCodecContext *s, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count);
    22622270int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count);
    22632271//FIXME func typedef
     2272void avcodec_default_decode_cc_dvd(AVCodecContext *c, const uint8_t *buf, int buf_size);
     2273void avcodec_default_decode_cc_atsc(AVCodecContext *c, const uint8_t *buf, int buf_size);
    22642274
    22652275/**
    22662276 * opens / inits the AVCodecContext.