← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/avidemux/jaunty

« back to all changes in this revision

Viewing changes to avidemux/ADM_outputs/oplug_flv/oplug_flv.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2009-02-17 23:41:46 UTC
  • mfrom: (1.1.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20090217234146-eakx254awuch4wgw
Tags: 1:2.4.4-0.0ubuntu1
* Merge from debian multimedia, Ubuntu remaining changes:
  - debian/control:
    + Build-Depends on newer libx264-dev.
    + Don't Build-Depends on ccache and libamrnb-dev.
    + Build-Depends on libpulse-dev.
    + Fixed small typo in avidemux description.
  - Don't use ccache.
  - Drop patch to fix build with newer x264, it has been merged by upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
avidemux/ADM_outputs/oplug_flv/oplug_flv.cpp
15
15
 *   (at your option) any later version.                                   *
16
16
 *                                                                         *
17
17
 ***************************************************************************/
 
18
#define __STDC_LIMIT_MACROS
 
19
 
18
20
#include "config.h"
19
21
#include <stdio.h>
20
22
#include <stdlib.h>
32
34
#include "ADM_editor/ADM_Video.h"
33
35
#include "ADM_colorspace/colorspace.h"
34
36
#include "ADM_toolkit/toolkit.hxx"
35
 
#include <ADM_assert.h>
 
37
#include "ADM_assert.h"
36
38
#include "ADM_video/ADM_genvideo.hxx"
37
39
#include "ADM_filter/video_filters.h"
38
40
 
93
95
uint32_t alen;//,flags;
94
96
uint32_t size;
95
97
 
96
 
uint8_t   ret=0;
97
 
 
98
98
uint32_t  sample_got=0,sample;
99
99
uint32_t  extraDataSize=0;
100
100
uint8_t   *extraData=NULL;
111
111
int prefill=0;
112
112
uint32_t displayFrame=0;
113
113
ADMBitstream    bitstream(0);
114
 
uint32_t        frameWrite=0;
115
114
uint8_t r=0;
116
 
uint32_t skipping=1;
117
115
pthread_t     audioThread;
118
116
audioQueueMT context;
119
117
PacketQueue   *pq=NULL;//("MP4 audioQ",50,2*1024*1024);
120
118
uint32_t    totalAudioSize=0;
121
 
uint32_t sent=0;
 
119
int frameDelay = 0;
 
120
bool receivedFrame = false;
122
121
 
123
122
        // Setup video
124
123
 
213
212
                        videoExtraData=new uint8_t[videoExtraDataSize];
214
213
                        memcpy(videoExtraData,dummy,videoExtraDataSize);
215
214
                }
216
 
        // _________________Setup video (cont) _______________
217
 
        // ___________ Read 1st frame _________________
218
215
 
219
216
             ADM_assert(_encode);
220
217
             bitstream.data=videoBuffer;
221
218
 
222
 
preFilling:
223
 
             bitstream.cleanup(0);
224
 
             if(!(err=_encode->encode ( prefill, &bitstream)))// FIXME: We should never execute it more than once
225
 
             {
226
 
                        printf("[FLV]:First frame error\n");
227
 
                        GUI_Error_HIG (QT_TR_NOOP("Error while encoding"), NULL);
228
 
                        goto  stopit;
229
 
              }
230
 
              sent++;
231
 
              if(!bitstream.len)
232
 
              {
233
 
                prefill++;
234
 
                goto preFilling;
235
 
              }
236
 
              if(!bitstream.flags & AVI_KEY_FRAME)
237
 
              {
238
 
                GUI_Error_HIG (QT_TR_NOOP("KeyFrame error"),QT_TR_NOOP( "The beginning frame is not a key frame.\nPlease move the A marker."));
239
 
                  goto  stopit;
240
 
              }
241
 
 
242
219
// ____________Setup audio__________________
243
220
          if(currentaudiostream)
244
221
          {
282
259
                encoding_gui->setCodec(_encode->getDisplayName());
283
260
           //
284
261
          UI_purge();
285
 
          if(bitstream.len)
286
 
          {
287
 
            muxer->writeVideoPacket( &bitstream);
288
 
            frameWrite++;
289
 
          }
 
262
 
290
263
//_____________ Start Audio thread _____________________
291
264
          if(audio)
292
265
          {
300
273
            ADM_usleep(4000);
301
274
          }
302
275
//_____________GO !___________________
303
 
           for(int frame=1;frame<total;frame++)
304
 
           {
305
 
               while(muxer->needAudio())
306
 
               {
307
 
                    if(pq->Pop(audioBuffer,&alen,&sample))
308
 
                    {
309
 
                     if(alen)
310
 
                     {
311
 
                        muxer->writeAudioPacket(alen,audioBuffer,sample_got);
312
 
                        totalAudioSize+=alen;
313
 
                        encoding_gui->setAudioSize(totalAudioSize);
314
 
                        sample_got+=sample;
315
 
                     }
316
 
                    }else break;
317
 
               }
318
 
               ADM_assert(_encode);
319
 
               bitstream.cleanup(frameWrite);
320
 
 
321
 
               r=_encode->encode ( prefill+frame, &bitstream);
322
 
 
323
 
               if(!r && frame<total-2)
324
 
               {
325
 
                        printf("[FLV]:Frame %u error\n",frame);
326
 
                        GUI_Error_HIG ("FLV",QT_TR_NOOP("Error while encoding"));
327
 
                        goto  stopit;
328
 
                }
329
 
                if(!bitstream.len && skipping)
330
 
                {
331
 
                    printf("[FLV]Frame skipped (xvid ?)\n");
332
 
                    continue;
333
 
                }
334
 
                sent++;
335
 
                skipping=0;
336
 
            //    printf("Prefill %u FrameWrite :%u Frame %u PtsFrame :%u\n",prefill,frameWrite,frame,bitstream.ptsFrame);
337
 
                frameWrite++;
338
 
                muxer->writeVideoPacket( &bitstream);
339
 
                encoding_gui->setFrame(frame,bitstream.len,bitstream.out_quantizer,total);
340
 
               if(!encoding_gui->isAlive())
341
 
                {
342
 
 
343
 
                    goto stopit;
344
 
                }
345
 
 
346
 
           }
347
 
           ret=1;
 
276
 
 
277
                         for (uint32_t frame = 0; frame < total; frame++)
 
278
                         {
 
279
                                 if (!encoding_gui->isAlive())
 
280
                                 {
 
281
                                         r = 0;
 
282
                                         break;
 
283
                                 }
 
284
 
 
285
                                 while(muxer->needAudio())
 
286
                                 {
 
287
                                         if(pq->Pop(audioBuffer,&alen,&sample))
 
288
                                         {
 
289
                                                 if(alen)
 
290
                                                 {
 
291
                                                         muxer->writeAudioPacket(alen,audioBuffer,sample_got);
 
292
                                                         totalAudioSize+=alen;
 
293
                                                         encoding_gui->setAudioSize(totalAudioSize);
 
294
                                                         sample_got+=sample;
 
295
                                                 }
 
296
                                         }
 
297
                                         else
 
298
                                         {
 
299
                                                 r = 0;
 
300
                                                 break;
 
301
                                         }
 
302
                                 }
 
303
 
 
304
                                 for (;;)
 
305
                                 {
 
306
                                         bitstream.cleanup(frame);
 
307
 
 
308
                                         if (frame + frameDelay >= total)
 
309
                                         {
 
310
                                                 if (_encode->getRequirements() & ADM_ENC_REQ_NULL_FLUSH)
 
311
                                                         r = _encode->encode(UINT32_MAX, &bitstream);
 
312
                                                 else
 
313
                                                         r = 0;
 
314
                                         }
 
315
                                         else
 
316
                                                 r = _encode->encode(frame + frameDelay, &bitstream);
 
317
 
 
318
                                         if (!r)
 
319
                                         {
 
320
                                                 printf("Encoding of frame %lu failed!\n", frame);
 
321
                                                 GUI_Error_HIG (QT_TR_NOOP("Error while encoding"), NULL);
 
322
                                                 break;
 
323
                                         }
 
324
                                         else if (!receivedFrame && bitstream.len > 0)
 
325
                                         {
 
326
                                                 if (!(bitstream.flags & AVI_KEY_FRAME))
 
327
                                                 {
 
328
                                                         GUI_Error_HIG (QT_TR_NOOP("KeyFrame error"), QT_TR_NOOP("The beginning frame is not a key frame.\nPlease move the A marker."));
 
329
                                                         r = 0;
 
330
                                                         break;
 
331
                                                 }
 
332
                                                 else
 
333
                                                         receivedFrame = true;
 
334
                                         }
 
335
 
 
336
                                         if (bitstream.len == 0 && (_encode->getRequirements() & ADM_ENC_REQ_NULL_FLUSH))
 
337
                                         {
 
338
                                                 printf("skipping frame: %u size: %i\n", frame + frameDelay, bitstream.len);
 
339
                                                 frameDelay++;
 
340
                                         }
 
341
                                         else
 
342
                                                 break;
 
343
                                 }
 
344
 
 
345
                                 if (!r)
 
346
                                         break;
 
347
 
 
348
                                 muxer->writeVideoPacket(&bitstream);
 
349
                                 encoding_gui->setFrame(frame, bitstream.len, bitstream.out_quantizer, total);
 
350
                         }
348
351
 
349
352
stopit:
350
353
 
370
373
           if(videoExtraData) delete [] videoExtraData;
371
374
           // Cleanup
372
375
           deleteAudioFilter (audio);
373
 
           return ret;
 
376
           return r;
374
377
}
375
378
 
376
379